utils-lib-js 2.0.10 → 2.0.12

package/dist/umd/index.js

@@ -19,6 +19,2998 @@
     PERFORMANCE OF THIS SOFTWARE.
     ***************************************************************************** */
 
+    var __assign$9 = function() {
+        __assign$9 = Object.assign || function __assign(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign$9.apply(this, arguments);
+    };
+
+    function __spreadArray$3(to, from, pack) {
+        if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+            if (ar || !(i in from)) {
+                if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+                ar[i] = from[i];
+            }
+        }
+        return to.concat(ar || Array.prototype.slice.call(from));
+    }
+
+    exports.types = void 0;
+    (function (types) {
+        types["[object Array]"] = "array";
+        types["[object Object]"] = "object";
+        types["[object Function]"] = "function";
+        types["[object Set]"] = "set";
+        types["[object Map]"] = "map";
+        types["[object WeakMap]"] = "weakMap";
+        types["[object WeakSet]"] = "weakSet";
+        types["[object Date]"] = "date";
+        types["[object RegExp]"] = "regExp";
+        types["[object Math]"] = "math";
+    })(exports.types || (exports.types = {}));
+    var __static$3 = { types: exports.types };
+
+    var randomNum$3 = function (min, max, bool) {
+        if (bool === void 0) { bool = false; }
+        return Math.floor(Math.random() * (max - min + (bool ? 1 : 0)) + min);
+    };
+    var urlSplit$3 = function (url) {
+        var result = {};
+        if (!url.includes("?")) {
+            return result;
+        }
+        var params = url.split("?")[1].split("&");
+        params.forEach(function (i) {
+            var key = i.split("=")[0];
+            result[key] = i.split("=")[1];
+        });
+        return result;
+    };
+    var urlJoin$3 = function (url, query) {
+        if (query === void 0) { query = {}; }
+        var queryObject = Object.keys(query);
+        if (queryObject.length === 0)
+            return url;
+        var params = queryObject.map(function (i) { return "".concat(i, "=").concat(query[i]); });
+        return "".concat(url).concat(url.includes("?") ? "&" : '?').concat(params.join("&"));
+    };
+    var getType$3 = function (data) {
+        var type = typeof data;
+        if (data === null) {
+            return "null";
+        }
+        else if (type === "object") {
+            var key = Object.prototype.toString.call(data);
+            return exports.types[key];
+        }
+        return type;
+    };
+    var getTypeByList$3 = function (data, whiteList) {
+        if (whiteList === void 0) { whiteList = []; }
+        var __type = getType$3(data);
+        return whiteList.indexOf(__type) > 0;
+    };
+    var base$3 = {
+        randomNum: randomNum$3,
+        urlSplit: urlSplit$3,
+        urlJoin: urlJoin$3,
+        getType: getType$3,
+        getTypeByList: getTypeByList$3,
+    };
+
+    var getValue$3 = function (object, key, defaultValue) {
+        if (defaultValue === void 0) { defaultValue = ''; }
+        var paths = key.split('.');
+        for (var _i = 0, paths_1 = paths; _i < paths_1.length; _i++) {
+            var i = paths_1[_i];
+            object = object[i];
+            if (object === undefined) {
+                return defaultValue;
+            }
+        }
+        return object;
+    };
+    var setValue$3 = function (object, key, value) {
+        if (value === void 0) { value = {}; }
+        var paths = key.split('.');
+        var last = paths[paths.length - 1];
+        var _object = object;
+        for (var _i = 0, paths_2 = paths; _i < paths_2.length; _i++) {
+            var i = paths_2[_i];
+            if (typeof _object !== "object" && _object !== undefined) {
+                return object;
+            }
+            !_object && (_object = {});
+            !_object[i] && (_object[i] = {});
+            last === i && (_object[last] = value);
+            _object = _object[i];
+        }
+        return object;
+    };
+    var mixIn$3 = function (target, source, overwrite) {
+        var _a;
+        if (source === void 0) { source = {}; }
+        if (overwrite === void 0) { overwrite = false; }
+        for (var k in source) {
+            for (var key in source[k]) {
+                var proto = (_a = target.prototype) !== null && _a !== void 0 ? _a : target;
+                if (target[key] === undefined || overwrite) {
+                    proto[key] = source[k][key];
+                }
+            }
+        }
+        return target;
+    };
+    var enumInversion$3 = function (target) {
+        for (var key in target) {
+            var _key = target[key];
+            if (typeof _key === "string" && !!!target[_key]) {
+                target[_key] = key;
+            }
+        }
+        return target;
+    };
+    var isNotObject$3 = function (source, type) { return (typeof source !== "object" || type === 'null'); };
+    var cloneDeep$3 = function (target) {
+        var __type = getType$3(target);
+        if (isNotObject$3(target, __type))
+            return target;
+        var __init = createObjectVariable$3(__type, target);
+        if (__type === "map") {
+            target.forEach(function (value, key) {
+                __init.set(key, cloneDeep$3(value));
+            });
+        }
+        else if (__type === "set") {
+            target.forEach(function (value) {
+                __init.add(cloneDeep$3(value));
+            });
+        }
+        else {
+            Reflect.ownKeys(target).forEach(function (keys) {
+                var desc = target[keys];
+                __init[keys] = cloneDeep$3(desc);
+            });
+        }
+        return __init;
+    };
+    var createObjectVariable$3 = function (type, source) {
+        if (source === void 0) { source = {}; }
+        switch (type) {
+            case "array":
+                return [];
+            case "function":
+                return source;
+            case "set":
+                return new Set();
+            case "map":
+                return new Map();
+            case "date":
+                return new Date(source);
+            case "regExp":
+                return new RegExp(source);
+            case "math":
+                return Math;
+            default:
+                return {};
+        }
+    };
+    var createObject$3 = function (source) {
+        function F() { }
+        F.prototype = source;
+        return new F();
+    };
+    var inherit$3 = function (source, target) {
+        if (target === void 0) { target = function () { }; }
+        target.prototype = createObject$3(source.prototype);
+        target.prototype.super = source;
+        target.prototype.constructor = target;
+        return target;
+    };
+    var getInstance$3 = function (classProto, overwrite) {
+        if (overwrite === void 0) { overwrite = false; }
+        var params = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+            params[_i - 2] = arguments[_i];
+        }
+        if (!classProto._instance || overwrite) {
+            classProto._instance = new (classProto.bind.apply(classProto, __spreadArray$3([void 0], params, false)))();
+        }
+        return classProto._instance;
+    };
+    var classDecorator$3 = function (params) {
+        return function (target) {
+            for (var key in params) {
+                if (!!!Reflect.has(target.prototype, key)) {
+                    target.prototype[key] = params[key];
+                }
+            }
+        };
+    };
+    var stringToJson$3 = function (target) {
+        if (getType$3(target) !== "string")
+            return null;
+        try {
+            return JSON.parse(target);
+        }
+        catch (error) {
+            return null;
+        }
+    };
+    var jsonToString$3 = function (target) {
+        if (!getTypeByList$3(target, ["array", "object", "set", "map"]))
+            return "";
+        try {
+            return JSON.stringify(target);
+        }
+        catch (error) {
+            return "";
+        }
+    };
+    var isWindow$3 = function (win) {
+        return win && win === win.window;
+    };
+    var emptyObject = function (init) {
+        var _o = Object.create(null);
+        Reflect.ownKeys(init).forEach(function (k) { return _o[k] = init[k]; });
+        return _o;
+    };
+    var object$3 = {
+        getValue: getValue$3,
+        setValue: setValue$3,
+        mixIn: mixIn$3,
+        enumInversion: enumInversion$3,
+        isNotObject: isNotObject$3,
+        cloneDeep: cloneDeep$3,
+        createObjectVariable: createObjectVariable$3,
+        createObject: createObject$3,
+        inherit: inherit$3,
+        getInstance: getInstance$3,
+        classDecorator: classDecorator$3,
+        stringToJson: stringToJson$3,
+        jsonToString: jsonToString$3,
+        isWindow: isWindow$3,
+        emptyObject: emptyObject,
+    };
+
+    var arrayRandom$3 = function (arr) { return arr.sort(function () { return Math.random() - 0.5; }); };
+    var arrayUniq$3 = function (arr) { return Array.from(new Set(arr)); };
+    var arrayDemote$3 = function (arr, result) {
+        if (result === void 0) { result = []; }
+        arr.forEach(function (i) { return getType$3(i) === "array" ? arrayDemote$3(i, result) : result.push(i); });
+        return result;
+    };
+    var array$3 = {
+        arrayRandom: arrayRandom$3,
+        arrayUniq: arrayUniq$3,
+        arrayDemote: arrayDemote$3
+    };
+
+    var _this$3 = undefined;
+    var throttle$3 = function (fn, time) {
+        var _timer = null;
+        return function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            if (_timer)
+                return;
+            _timer = setTimeout(function () {
+                fn.call.apply(fn, __spreadArray$3([_this$3], args, false));
+                _timer = null;
+            }, time);
+        };
+    };
+    var debounce$3 = function (fn, time) {
+        var _timer = null;
+        return function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            if (_timer) {
+                clearTimeout(_timer);
+                _timer = null;
+            }
+            _timer = setTimeout(function () {
+                fn.call.apply(fn, __spreadArray$3([_this$3], args, false));
+            }, time);
+        };
+    };
+    var defer$3 = function (timer) {
+        if (timer === void 0) { timer = 0; }
+        var resolve, reject;
+        return {
+            promise: new Promise(function (_resolve, _reject) {
+                resolve = _resolve;
+                reject = _reject;
+                if (timer > 0)
+                    setTimeout(function () { return reject("timeout"); }, timer);
+            }),
+            resolve: resolve,
+            reject: reject
+        };
+    };
+    var catchAwait$3 = function (defer) { return defer.then(function (res) { return [null, res]; }).catch(function (err) { return [err]; }); };
+    var requestFrame$1 = function (callback, delay) {
+        if (delay === void 0) { delay = 0; }
+        if (!callback)
+            throw Error("callback is empty");
+        var isNodeEnv = typeof process !== "undefined";
+        var frameFn = isNodeEnv ? setImmediate : requestAnimationFrame;
+        var _p = performance;
+        var start = _p.now();
+        var freeze = false;
+        var clear = function () { return freeze = true; };
+        var _tempCb = function () {
+            if (freeze)
+                return;
+            var diff = _p.now() - start;
+            if (diff >= delay) {
+                start = _p.now();
+                callback(start);
+            }
+            frameFn(_tempCb);
+        };
+        _tempCb();
+        return clear;
+    };
+    var __function$3 = {
+        throttle: throttle$3,
+        debounce: debounce$3,
+        defer: defer$3,
+        catchAwait: catchAwait$3,
+    };
+
+    var createElement$3 = function (_a) {
+        var _b, _c;
+        var ele = _a.ele, style = _a.style, attr = _a.attr, parent = _a.parent;
+        var element = ele instanceof HTMLElement ? ele : document.createElement(ele !== null && ele !== void 0 ? ele : 'div');
+        style && ((_b = Object.keys(style)) === null || _b === void 0 ? void 0 : _b.forEach(function (key) { return element.style[key] = style[key]; }));
+        attr && ((_c = Object.keys(attr)) === null || _c === void 0 ? void 0 : _c.forEach(function (key) { return element[key] = attr[key]; }));
+        parent && parent.appendChild(element);
+        return element;
+    };
+    var element$3 = {
+        createElement: createElement$3
+    };
+
+    var addHandler$3 = function (ele, type, handler) {
+        if (ele.addEventListener) {
+            ele.addEventListener(type, handler, false);
+        }
+        else {
+            ele["on" + type] = handler;
+        }
+    };
+    var stopBubble$3 = function (event) {
+        event = event || window.event;
+        if (event.stopPropagation) {
+            event.stopPropagation();
+        }
+        else {
+            event.cancelBubble = false;
+        }
+    };
+    var stopDefault$3 = function (event) {
+        event = event || window.event;
+        if (event.preventDefault) {
+            event.preventDefault();
+        }
+        else {
+            event.returnValue = false;
+        }
+    };
+    var removeHandler$3 = function (ele, type, handler) {
+        if (ele.removeEventListener) {
+            ele.removeEventListener(type, handler, false);
+        }
+        else {
+            ele["on" + type] = null;
+        }
+    };
+    var dispatchEvent$3 = function (ele, data) {
+        var evts = new Event(data);
+        ele.dispatchEvent(evts);
+    };
+    var event$3 = {
+        addHandler: addHandler$3,
+        stopBubble: stopBubble$3,
+        stopDefault: stopDefault$3,
+        removeHandler: removeHandler$3,
+        dispatchEvent: dispatchEvent$3,
+    };
+
+    var setStorage$3 = function (key, val) {
+        try {
+            localStorage.setItem(key, JSON.stringify(val));
+        }
+        catch (error) {
+            console.error(error);
+        }
+    };
+    var getStorage$3 = function (key) {
+        try {
+            var str = localStorage.getItem(key);
+            if (str === null || str === undefined) {
+                return null;
+            }
+            return JSON.parse(str);
+        }
+        catch (error) {
+            console.error(error);
+            return null;
+        }
+    };
+    var clearStorage$3 = function (key) {
+        try {
+            key && localStorage.removeItem(key);
+            !key && localStorage.clear();
+        }
+        catch (error) {
+            console.error(error);
+        }
+    };
+    var storage$3 = {
+        setStorage: setStorage$3,
+        getStorage: getStorage$3,
+        clearStorage: clearStorage$3
+    };
+
+    var logOneLine$3 = function (str, overwrite, warp) {
+        if (overwrite === void 0) { overwrite = false; }
+        if (warp === void 0) { warp = true; }
+        if (overwrite) {
+            process.stdout.clearLine(0);
+            process.stdout.cursorTo(0);
+        }
+        process.stdout.write(str);
+        warp && process.stdout.write("\n");
+    };
+    var renderLoop$3 = function (str) { return logOneLine$3(str, true, false); };
+    var defaultLoopList$3 = ["\\", "|", "/", "\u2014", "\u2014"];
+    var logLoop$3 = function (opts) {
+        var _a;
+        if (opts === void 0) { opts = {}; }
+        var _b = opts.loopList, loopList = _b === void 0 ? defaultLoopList$3 : _b, _c = opts.isStop, isStop = _c === void 0 ? false : _c, _d = opts.timer, timer = _d === void 0 ? 100 : _d;
+        var _e = opts.index, index = _e === void 0 ? 0 : _e;
+        var len = (_a = loopList === null || loopList === void 0 ? void 0 : loopList.length) !== null && _a !== void 0 ? _a : 0;
+        if (!!!len)
+            return opts;
+        if (isStop)
+            return renderLoop$3("\n");
+        if (index >= len - 1)
+            index = 0;
+        var str = loopList[index++];
+        renderLoop$3(str);
+        setTimeout(function () {
+            opts.index = index;
+            logLoop$3(opts);
+        }, timer);
+        return opts;
+    };
+    var log$3 = {
+        logOneLine: logOneLine$3,
+        logLoop: logLoop$3
+    };
+
+    var AnimateFrame$3 = (function () {
+        function AnimateFrame(fn) {
+            this.fn = fn;
+            this.id = null;
+            this.duration = Infinity;
+            this.isActive = false;
+        }
+        AnimateFrame.prototype.start = function (duration) {
+            if (this.isActive)
+                return;
+            this.duration = duration !== null && duration !== void 0 ? duration : Infinity;
+            this.isActive = true;
+            return this.animate();
+        };
+        AnimateFrame.prototype.stop = function (id) {
+            if (id === void 0) { id = this.id; }
+            this.isActive = false;
+            cancelAnimationFrame(id);
+        };
+        AnimateFrame.prototype.animate = function (timer) {
+            if (timer === void 0) { timer = 0; }
+            if (this.isActive && this.duration-- > 0) {
+                this.fn(timer);
+                this.id = requestAnimationFrame(this.animate.bind(this));
+                return this.id;
+            }
+        };
+        return AnimateFrame;
+    }());
+    function quadraticBezier$3(_x, _y, t) {
+        var mt = 1 - t;
+        var t2 = t * t;
+        var x = 2 * mt * t * _x + t2;
+        var y = 2 * mt * t * _y + t2;
+        return [x, y];
+    }
+    function cubicBezier$3(_x1, _y1, _x2, _y2, t) {
+        var cx = 3 * _x1;
+        var cy = 3 * _y1;
+        var bx = 3 * (_x2 - _x1) - cx;
+        var by = 3 * (_y2 - _y1) - cy;
+        var ax = 1 - cx - bx;
+        var ay = 1 - cy - by;
+        var x = ax * Math.pow(t, 3) + bx * Math.pow(t, 2) + cx * t;
+        var y = ay * Math.pow(t, 3) + by * Math.pow(t, 2) + cy * t;
+        return [x, y];
+    }
+    function factorial$3(n) {
+        if (n === 0 || n === 1) {
+            return 1;
+        }
+        return n * factorial$3(n - 1);
+    }
+    function combination$3(n, k) {
+        return factorial$3(n) / (factorial$3(k) * factorial$3(n - k));
+    }
+    function NBezier$3(points, t) {
+        var n = points.length - 1;
+        var result = [0, 0];
+        for (var i = 0; i <= n; i++) {
+            var coefficient = combination$3(n, i) * Math.pow(1 - t, n - i) * Math.pow(t, i);
+            result[0] += coefficient * points[i][0];
+            result[1] += coefficient * points[i][1];
+        }
+        return result;
+    }
+    var animate$3 = {
+        AnimateFrame: AnimateFrame$3,
+        quadraticBezier: quadraticBezier$3,
+        cubicBezier: cubicBezier$3,
+        factorial: factorial$3,
+        combination: combination$3,
+        NBezier: NBezier$3,
+    };
+
+    var MessageCenter$3 = (function () {
+        function MessageCenter(options) {
+            if (options === void 0) { options = {}; }
+            this.options = options;
+            this.events = {};
+        }
+        MessageCenter.prototype.on = function (type, handler) {
+            this.checkHandler(type, handler);
+            var fns = this.getHandler(type, []);
+            fns.push(handler);
+            return this;
+        };
+        MessageCenter.prototype.emit = function (type, data) {
+            if (this.has(type)) {
+                this.runHandler(type, data);
+            }
+            return this;
+        };
+        MessageCenter.prototype.un = function (type, handler) {
+            this.unHandler(type, handler);
+            return this;
+        };
+        MessageCenter.prototype.once = function (type, handler) {
+            var _this = this;
+            this.checkHandler(type, handler);
+            var fn = function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                _this.un(type, fn);
+                return handler.apply(void 0, args);
+            };
+            this.on(type, fn);
+            return this;
+        };
+        MessageCenter.prototype.clear = function () {
+            this.events = {};
+            return this;
+        };
+        MessageCenter.prototype.has = function (type) {
+            return !!this.getHandler(type);
+        };
+        MessageCenter.prototype.getHandler = function (type, defaultVal) {
+            var _a;
+            typeof defaultVal === "object" && (this.events[type] = (_a = this.events[type]) !== null && _a !== void 0 ? _a : defaultVal);
+            return this.events[type];
+        };
+        MessageCenter.prototype.handlerLength = function (type) {
+            var _a, _b;
+            return (_b = (_a = this.getHandler(type)) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+        };
+        MessageCenter.prototype.watch = function (type, handler) {
+            var _this = this;
+            this.checkHandler(type, handler);
+            var fn = function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                _this.emit(_this.prefixStr(type), handler.apply(void 0, args));
+            };
+            this.on(type, fn);
+            return this;
+        };
+        MessageCenter.prototype.invoke = function (type, data) {
+            var _this = this;
+            return new Promise(function (resolve) {
+                _this.once(_this.prefixStr(type), resolve);
+                _this.emit(type, data);
+            });
+        };
+        MessageCenter.prototype.runHandler = function (type, data) {
+            var _fns = this.getHandler(type);
+            for (var _i = 0, _fns_1 = _fns; _i < _fns_1.length; _i++) {
+                var fn = _fns_1[_i];
+                fn && fn(data);
+            }
+        };
+        MessageCenter.prototype.unHandler = function (type, handler) {
+            var _fns = this.getHandler(type);
+            !handler && (this.events[type] = []);
+            handler && this.checkHandler(type, handler);
+            for (var i = 0; i < _fns.length; i++) {
+                if (_fns && _fns[i] === handler) {
+                    _fns[i] = null;
+                }
+            }
+        };
+        MessageCenter.prototype.prefixStr = function (str) {
+            return "@".concat(str);
+        };
+        MessageCenter.prototype.checkHandler = function (type, handler) {
+            var _a = this.options, _b = _a.blackList, blackList = _b === void 0 ? [] : _b, _c = _a.maxLen, maxLen = _c === void 0 ? Infinity : _c;
+            var len = this.handlerLength(type);
+            if ((type === null || type === void 0 ? void 0 : type.length) === 0) {
+                throw new Error('type.length can not be 0');
+            }
+            if (!handler || !type) {
+                throw new ReferenceError('type or handler is not defined');
+            }
+            if (typeof handler !== 'function' || typeof type !== 'string') {
+                throw new TypeError("".concat(handler, " is not a function or ").concat(type, " is not a string"));
+            }
+            if (blackList.includes(type)) {
+                throw new Error("".concat(type, " is not allow"));
+            }
+            if (maxLen <= len) {
+                throw new Error("the number of ".concat(type, " must be less than ").concat(maxLen));
+            }
+        };
+        MessageCenter.Instance = function (Fn) {
+            if (!Fn._instance) {
+                Object.defineProperty(Fn, "_instance", {
+                    value: new Fn()
+                });
+            }
+            return Fn._instance;
+        };
+        return MessageCenter;
+    }());
+    var messageCenter = MessageCenter$3.Instance(MessageCenter$3);
+    var decoratorMessageCenter$3 = function (target) {
+        if (!target.prototype.messageCenter) {
+            target.prototype.messageCenter = new MessageCenter$3();
+        }
+        return target;
+    };
+
+    var __assign$8 = (undefined && undefined.__assign) || function () {
+        __assign$8 = Object.assign || function(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                    t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign$8.apply(this, arguments);
+    };
+    var __decorate$3 = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+        if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+        else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+        return c > 3 && r && Object.defineProperty(target, key, r), r;
+    };
+    var __metadata$3 = (undefined && undefined.__metadata) || function (k, v) {
+        if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+    };
+    var __awaiter$3 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+            step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+    };
+    var __generator$3 = (undefined && undefined.__generator) || function (thisArg, body) {
+        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+        function verb(n) { return function (v) { return step([n, v]); }; }
+        function step(op) {
+            if (f) throw new TypeError("Generator is already executing.");
+            while (g && (g = 0, op[0] && (_ = 0)), _) try {
+                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+                if (y = 0, t) op = [op[0] & 2, t.value];
+                switch (op[0]) {
+                    case 0: case 1: t = op; break;
+                    case 4: _.label++; return { value: op[1], done: false };
+                    case 5: _.label++; y = op[1]; op = [0]; continue;
+                    case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                    default:
+                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                        if (t[2]) _.ops.pop();
+                        _.trys.pop(); continue;
+                }
+                op = body.call(thisArg, _);
+            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+        }
+    };
+    var TaskQueue$3 = (function () {
+        function TaskQueue(props) {
+            var _this = this;
+            this.fix = "@~&$";
+            this.init = function () {
+                _this.messageCenter.on("push:handler", _this.run);
+                _this.messageCenter.on("run:success:handler", _this.run);
+                _this.messageCenter.on("run:success:handler", _this.finish);
+                _this.messageCenter.on("run:error:handler", _this.run);
+                _this.messageCenter.on("run:error:handler", _this.finish);
+            };
+            this.defineProps = function (props, key) {
+                Object.defineProperty(_this, key, { value: props });
+            };
+            this.push = function (queue) {
+                var _a;
+                _this.checkHandler(queue);
+                var resolve = (_a = _this.defer(), _a.resolve), reject = _a.reject, promise = _a.promise;
+                var queueName = _this.fixStr(queue.name);
+                _this.queues = _this.queues.concat(queue.children.map(function (defer) { return ({ defer: defer, name: queueName }); }));
+                _this.queueTemp[queueName] = __assign$8(__assign$8({}, queue), { result: [] });
+                _this.messageCenter.emit("push:handler", reject);
+                _this.messageCenter.on(queueName, resolve);
+                return promise;
+            };
+            this.unshift = function (length) {
+                return _this.queues.splice(0, length);
+            };
+            this.run = function (_a) {
+                var reject = _a.reject;
+                return __awaiter$3(_this, void 0, void 0, function () {
+                    var queues, res, error_1;
+                    var _b, _c;
+                    return __generator$3(this, function (_d) {
+                        switch (_d.label) {
+                            case 0:
+                                if (this.stateProxy() === 'pending')
+                                    return [2, void 0];
+                                if (this.queues.length === 0)
+                                    return [2, this.stateProxy("idle")];
+                                this.stateProxy("pending");
+                                queues = this.unshift((_c = (_b = this.props) === null || _b === void 0 ? void 0 : _b.maxLen) !== null && _c !== void 0 ? _c : 10);
+                                _d.label = 1;
+                            case 1:
+                                _d.trys.push([1, 3, , 4]);
+                                return [4, Promise.all(queues.map(function (item, i) { return item.defer().catch(function (error) { return error; }); }))];
+                            case 2:
+                                res = _d.sent();
+                                return [2, this.handlerSuccess({ res: res, queues: queues })];
+                            case 3:
+                                error_1 = _d.sent();
+                                return [2, this.handlerError({ reject: reject, error: error_1, queues: queues })];
+                            case 4: return [2];
+                        }
+                    });
+                });
+            };
+            this.clear = function () {
+                _this.queues = [];
+                _this.queueTemp = {};
+                _this.props = null;
+                _this.stateProxy("idle");
+                _this.messageCenter.clear();
+            };
+            this.finish = function (_a) {
+                var _b = _a.res, res = _b === void 0 ? [] : _b, queues = _a.queues, _c = _a.error, error = _c === void 0 ? 'err' : _c;
+                var queueTemp = _this.queueTemp;
+                queues.forEach(function (it, i) {
+                    var _a, _b, _c;
+                    var item = queueTemp[it.name];
+                    item === null || item === void 0 ? void 0 : item.result.push((_a = res[i]) !== null && _a !== void 0 ? _a : error);
+                    if (((_b = item === null || item === void 0 ? void 0 : item.result) === null || _b === void 0 ? void 0 : _b.length) === ((_c = item === null || item === void 0 ? void 0 : item.children) === null || _c === void 0 ? void 0 : _c.length)) {
+                        _this.messageCenter.emit(it.name, item === null || item === void 0 ? void 0 : item.result);
+                        queueTemp[it.name] = null;
+                    }
+                });
+            };
+            this.handlerSuccess = function (data) {
+                _this.stateProxy("fulfilled");
+                return _this.messageCenter.emit("run:success:handler", data);
+            };
+            this.handlerError = function (data) {
+                var reject = data.reject, error = data.error;
+                _this.stateProxy("rejected");
+                reject && typeof reject === "function" && reject(error);
+                return _this.messageCenter.emit("run:error:handler", data);
+            };
+            this.stateProxy = function (state) {
+                state && (_this.state = state);
+                return _this.state;
+            };
+            this.defer = function () {
+                var resolve, reject;
+                return {
+                    promise: new Promise(function (_resolve, _reject) {
+                        resolve = _resolve;
+                        reject = _reject;
+                    }),
+                    resolve: resolve,
+                    reject: reject
+                };
+            };
+            this.clear();
+            props && this.defineProps(props, "props");
+            this.init();
+        }
+        TaskQueue.prototype.checkHandler = function (queue) {
+            var _a, _b;
+            if (!queue) {
+                throw new ReferenceError('queue is not defined');
+            }
+            if (!(queue.children instanceof Array) || typeof queue !== "object") {
+                throw new TypeError("queue should be an object and queue.children should be an array");
+            }
+            var noFn = function (i) { return !i || typeof i !== "function"; };
+            if (((_a = queue.children) === null || _a === void 0 ? void 0 : _a.length) === 0)
+                throw new Error('queue.children.length can not be 0');
+            if ((_b = queue.children) === null || _b === void 0 ? void 0 : _b.find(function (i) { return noFn(i); }))
+                throw new Error('queueList should have defer');
+        };
+        TaskQueue.prototype.fixStr = function (str) {
+            return "".concat(this.fix).concat(str);
+        };
+        TaskQueue = __decorate$3([
+            decoratorMessageCenter$3,
+            __metadata$3("design:paramtypes", [Object])
+        ], TaskQueue);
+        return TaskQueue;
+    }());
+    var decoratorTaskQueue = function (opts) {
+        return function (target) {
+            if (!target.prototype.taskQueue) {
+                target.prototype.taskQueue = new TaskQueue$3(opts);
+            }
+        };
+    };
+
+    /******************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+
+    var __assign$1$1 = function() {
+        __assign$1$1 = Object.assign || function __assign(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign$1$1.apply(this, arguments);
+    };
+
+    function __spreadArray$2(to, from, pack) {
+        if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+            if (ar || !(i in from)) {
+                if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+                ar[i] = from[i];
+            }
+        }
+        return to.concat(ar || Array.prototype.slice.call(from));
+    }
+
+    var types$2;
+    (function (types) {
+        types["[object Array]"] = "array";
+        types["[object Object]"] = "object";
+        types["[object Function]"] = "function";
+        types["[object Set]"] = "set";
+        types["[object Map]"] = "map";
+        types["[object WeakMap]"] = "weakMap";
+        types["[object WeakSet]"] = "weakSet";
+        types["[object Date]"] = "date";
+        types["[object RegExp]"] = "regExp";
+        types["[object Math]"] = "math";
+    })(types$2 || (types$2 = {}));
+    var __static$2 = { types: types$2 };
+
+    var randomNum$2 = function (min, max, bool) {
+        if (bool === void 0) { bool = false; }
+        return Math.floor(Math.random() * (max - min + (bool ? 1 : 0)) + min);
+    };
+    var urlSplit$2 = function (url) {
+        var result = {};
+        if (!url.includes("?")) {
+            return result;
+        }
+        var params = url.split("?")[1].split("&");
+        params.forEach(function (i) {
+            var key = i.split("=")[0];
+            result[key] = i.split("=")[1];
+        });
+        return result;
+    };
+    var urlJoin$2 = function (url, query) {
+        if (query === void 0) { query = {}; }
+        var queryObject = Object.keys(query);
+        if (queryObject.length === 0)
+            return url;
+        var params = queryObject.map(function (i) { return "".concat(i, "=").concat(query[i]); });
+        return "".concat(url).concat(url.includes("?") ? "&" : '?').concat(params.join("&"));
+    };
+    var getType$2 = function (data) {
+        var type = typeof data;
+        if (data === null) {
+            return "null";
+        }
+        else if (type === "object") {
+            var key = Object.prototype.toString.call(data);
+            return types$2[key];
+        }
+        return type;
+    };
+    var getTypeByList$2 = function (data, whiteList) {
+        if (whiteList === void 0) { whiteList = []; }
+        var __type = getType$2(data);
+        return whiteList.indexOf(__type) > 0;
+    };
+    var base$2 = {
+        randomNum: randomNum$2,
+        urlSplit: urlSplit$2,
+        urlJoin: urlJoin$2,
+        getType: getType$2,
+        getTypeByList: getTypeByList$2,
+    };
+
+    var getValue$2 = function (object, key, defaultValue) {
+        if (defaultValue === void 0) { defaultValue = ''; }
+        var paths = key.split('.');
+        for (var _i = 0, paths_1 = paths; _i < paths_1.length; _i++) {
+            var i = paths_1[_i];
+            object = object[i];
+            if (object === undefined) {
+                return defaultValue;
+            }
+        }
+        return object;
+    };
+    var setValue$2 = function (object, key, value) {
+        if (value === void 0) { value = {}; }
+        var paths = key.split('.');
+        var last = paths[paths.length - 1];
+        var _object = object;
+        for (var _i = 0, paths_2 = paths; _i < paths_2.length; _i++) {
+            var i = paths_2[_i];
+            if (typeof _object !== "object" && _object !== undefined) {
+                return object;
+            }
+            !_object && (_object = {});
+            !_object[i] && (_object[i] = {});
+            last === i && (_object[last] = value);
+            _object = _object[i];
+        }
+        return object;
+    };
+    var mixIn$2 = function (target, source, overwrite) {
+        var _a;
+        if (source === void 0) { source = {}; }
+        if (overwrite === void 0) { overwrite = false; }
+        for (var k in source) {
+            for (var key in source[k]) {
+                var proto = (_a = target.prototype) !== null && _a !== void 0 ? _a : target;
+                if (target[key] === undefined || overwrite) {
+                    proto[key] = source[k][key];
+                }
+            }
+        }
+        return target;
+    };
+    var enumInversion$2 = function (target) {
+        for (var key in target) {
+            var _key = target[key];
+            if (typeof _key === "string" && !!!target[_key]) {
+                target[_key] = key;
+            }
+        }
+        return target;
+    };
+    var isNotObject$2 = function (source, type) { return (typeof source !== "object" || type === 'null'); };
+    var cloneDeep$2 = function (target) {
+        var __type = getType$2(target);
+        if (isNotObject$2(target, __type))
+            return target;
+        var __init = createObjectVariable$2(__type, target);
+        if (__type === "map") {
+            target.forEach(function (value, key) {
+                __init.set(key, cloneDeep$2(value));
+            });
+        }
+        else if (__type === "set") {
+            target.forEach(function (value) {
+                __init.add(cloneDeep$2(value));
+            });
+        }
+        else {
+            Reflect.ownKeys(target).forEach(function (keys) {
+                var desc = target[keys];
+                __init[keys] = cloneDeep$2(desc);
+            });
+        }
+        return __init;
+    };
+    var createObjectVariable$2 = function (type, source) {
+        if (source === void 0) { source = {}; }
+        switch (type) {
+            case "array":
+                return [];
+            case "function":
+                return source;
+            case "set":
+                return new Set();
+            case "map":
+                return new Map();
+            case "date":
+                return new Date(source);
+            case "regExp":
+                return new RegExp(source);
+            case "math":
+                return Math;
+            default:
+                return {};
+        }
+    };
+    var createObject$2 = function (source) {
+        function F() { }
+        F.prototype = source;
+        return new F();
+    };
+    var inherit$2 = function (source, target) {
+        if (target === void 0) { target = function () { }; }
+        target.prototype = createObject$2(source.prototype);
+        target.prototype.super = source;
+        target.prototype.constructor = target;
+        return target;
+    };
+    var getInstance$2 = function (classProto, overwrite) {
+        if (overwrite === void 0) { overwrite = false; }
+        var params = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+            params[_i - 2] = arguments[_i];
+        }
+        if (!classProto._instance || overwrite) {
+            classProto._instance = new (classProto.bind.apply(classProto, __spreadArray$2([void 0], params, false)))();
+        }
+        return classProto._instance;
+    };
+    var classDecorator$2 = function (params) {
+        return function (target) {
+            for (var key in params) {
+                if (!!!Reflect.has(target.prototype, key)) {
+                    target.prototype[key] = params[key];
+                }
+            }
+        };
+    };
+    var stringToJson$2 = function (target) {
+        if (getType$2(target) !== "string")
+            return null;
+        try {
+            return JSON.parse(target);
+        }
+        catch (error) {
+            return null;
+        }
+    };
+    var jsonToString$2 = function (target) {
+        if (!getTypeByList$2(target, ["array", "object", "set", "map"]))
+            return "";
+        try {
+            return JSON.stringify(target);
+        }
+        catch (error) {
+            return "";
+        }
+    };
+    var isWindow$2 = function (win) {
+        return win && win === win.window;
+    };
+    var object$2 = {
+        getValue: getValue$2,
+        setValue: setValue$2,
+        mixIn: mixIn$2,
+        enumInversion: enumInversion$2,
+        isNotObject: isNotObject$2,
+        cloneDeep: cloneDeep$2,
+        createObjectVariable: createObjectVariable$2,
+        createObject: createObject$2,
+        inherit: inherit$2,
+        getInstance: getInstance$2,
+        classDecorator: classDecorator$2,
+        stringToJson: stringToJson$2,
+        jsonToString: jsonToString$2,
+        isWindow: isWindow$2,
+    };
+
+    var arrayRandom$2 = function (arr) { return arr.sort(function () { return Math.random() - 0.5; }); };
+    var arrayUniq$2 = function (arr) { return Array.from(new Set(arr)); };
+    var arrayDemote$2 = function (arr, result) {
+        if (result === void 0) { result = []; }
+        arr.forEach(function (i) { return getType$2(i) === "array" ? arrayDemote$2(i, result) : result.push(i); });
+        return result;
+    };
+    var array$2 = {
+        arrayRandom: arrayRandom$2,
+        arrayUniq: arrayUniq$2,
+        arrayDemote: arrayDemote$2
+    };
+
+    var _this$2 = undefined;
+    var throttle$2 = function (fn, time) {
+        var _timer = null;
+        return function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            if (_timer)
+                return;
+            _timer = setTimeout(function () {
+                fn.call.apply(fn, __spreadArray$2([_this$2], args, false));
+                _timer = null;
+            }, time);
+        };
+    };
+    var debounce$2 = function (fn, time) {
+        var _timer = null;
+        return function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            if (_timer) {
+                clearTimeout(_timer);
+                _timer = null;
+            }
+            _timer = setTimeout(function () {
+                fn.call.apply(fn, __spreadArray$2([_this$2], args, false));
+            }, time);
+        };
+    };
+    var defer$2 = function (timer) {
+        if (timer === void 0) { timer = 0; }
+        var resolve, reject;
+        if (timer > 0)
+            setTimeout(reject, timer);
+        return {
+            promise: new Promise(function (_resolve, _reject) {
+                resolve = _resolve;
+                reject = _reject;
+            }),
+            resolve: resolve,
+            reject: reject
+        };
+    };
+    var catchAwait$2 = function (defer) { return defer.then(function (res) { return [null, res]; }).catch(function (err) { return [err]; }); };
+    var __function$2 = {
+        throttle: throttle$2,
+        debounce: debounce$2,
+        defer: defer$2,
+        catchAwait: catchAwait$2,
+    };
+
+    var createElement$2 = function (_a) {
+        var _b, _c;
+        var ele = _a.ele, style = _a.style, attr = _a.attr, parent = _a.parent;
+        var element = ele instanceof HTMLElement ? ele : document.createElement(ele !== null && ele !== void 0 ? ele : 'div');
+        style && ((_b = Object.keys(style)) === null || _b === void 0 ? void 0 : _b.forEach(function (key) { return element.style[key] = style[key]; }));
+        attr && ((_c = Object.keys(attr)) === null || _c === void 0 ? void 0 : _c.forEach(function (key) { return element[key] = attr[key]; }));
+        parent && parent.appendChild(element);
+        return element;
+    };
+    var element$2 = {
+        createElement: createElement$2
+    };
+
+    var addHandler$2 = function (ele, type, handler) {
+        if (ele.addEventListener) {
+            ele.addEventListener(type, handler, false);
+        }
+        else {
+            ele["on" + type] = handler;
+        }
+    };
+    var stopBubble$2 = function (event) {
+        event = event || window.event;
+        if (event.stopPropagation) {
+            event.stopPropagation();
+        }
+        else {
+            event.cancelBubble = false;
+        }
+    };
+    var stopDefault$2 = function (event) {
+        event = event || window.event;
+        if (event.preventDefault) {
+            event.preventDefault();
+        }
+        else {
+            event.returnValue = false;
+        }
+    };
+    var removeHandler$2 = function (ele, type, handler) {
+        if (ele.removeEventListener) {
+            ele.removeEventListener(type, handler, false);
+        }
+        else {
+            ele["on" + type] = null;
+        }
+    };
+    var dispatchEvent$2 = function (ele, data) {
+        var evts = new Event(data);
+        ele.dispatchEvent(evts);
+    };
+    var event$2 = {
+        addHandler: addHandler$2,
+        stopBubble: stopBubble$2,
+        stopDefault: stopDefault$2,
+        removeHandler: removeHandler$2,
+        dispatchEvent: dispatchEvent$2,
+    };
+
+    var setStorage$2 = function (key, val) {
+        try {
+            localStorage.setItem(key, JSON.stringify(val));
+        }
+        catch (error) {
+            console.error(error);
+        }
+    };
+    var getStorage$2 = function (key) {
+        try {
+            var str = localStorage.getItem(key);
+            if (str === null || str === undefined) {
+                return null;
+            }
+            return JSON.parse(str);
+        }
+        catch (error) {
+            console.error(error);
+            return null;
+        }
+    };
+    var clearStorage$2 = function (key) {
+        try {
+            key && localStorage.removeItem(key);
+            !key && localStorage.clear();
+        }
+        catch (error) {
+            console.error(error);
+        }
+    };
+    var storage$2 = {
+        setStorage: setStorage$2,
+        getStorage: getStorage$2,
+        clearStorage: clearStorage$2
+    };
+
+    var logOneLine$2 = function (str, overwrite, warp) {
+        if (overwrite === void 0) { overwrite = false; }
+        if (warp === void 0) { warp = true; }
+        if (overwrite) {
+            process.stdout.clearLine(0);
+            process.stdout.cursorTo(0);
+        }
+        process.stdout.write(str);
+        warp && process.stdout.write("\n");
+    };
+    var renderLoop$2 = function (str) { return logOneLine$2(str, true, false); };
+    var defaultLoopList$2 = ["\\", "|", "/", "\u2014", "\u2014"];
+    var logLoop$2 = function (opts) {
+        var _a;
+        if (opts === void 0) { opts = {}; }
+        var _b = opts.loopList, loopList = _b === void 0 ? defaultLoopList$2 : _b, _c = opts.isStop, isStop = _c === void 0 ? false : _c, _d = opts.timer, timer = _d === void 0 ? 100 : _d;
+        var _e = opts.index, index = _e === void 0 ? 0 : _e;
+        var len = (_a = loopList === null || loopList === void 0 ? void 0 : loopList.length) !== null && _a !== void 0 ? _a : 0;
+        if (!!!len)
+            return opts;
+        if (isStop)
+            return renderLoop$2("\n");
+        if (index >= len - 1)
+            index = 0;
+        var str = loopList[index++];
+        renderLoop$2(str);
+        setTimeout(function () {
+            opts.index = index;
+            logLoop$2(opts);
+        }, timer);
+        return opts;
+    };
+    var log$2 = {
+        logOneLine: logOneLine$2,
+        logLoop: logLoop$2
+    };
+
+    var AnimateFrame$2 = (function () {
+        function AnimateFrame(fn) {
+            this.fn = fn;
+            this.id = null;
+            this.duration = Infinity;
+            this.isActive = false;
+        }
+        AnimateFrame.prototype.start = function (duration) {
+            if (this.isActive)
+                return;
+            this.duration = duration !== null && duration !== void 0 ? duration : Infinity;
+            this.isActive = true;
+            this.animate();
+        };
+        AnimateFrame.prototype.stop = function () {
+            this.isActive = false;
+            cancelAnimationFrame(this.id);
+        };
+        AnimateFrame.prototype.animate = function (timer) {
+            if (timer === void 0) { timer = 0; }
+            if (this.isActive && this.duration-- > 0) {
+                this.fn(timer);
+                this.id = requestAnimationFrame(this.animate.bind(this));
+            }
+        };
+        return AnimateFrame;
+    }());
+    function quadraticBezier$2(_x, _y, t) {
+        var mt = 1 - t;
+        var t2 = t * t;
+        var x = 2 * mt * t * _x + t2;
+        var y = 2 * mt * t * _y + t2;
+        return [x, y];
+    }
+    function cubicBezier$2(_x1, _y1, _x2, _y2, t) {
+        var cx = 3 * _x1;
+        var cy = 3 * _y1;
+        var bx = 3 * (_x2 - _x1) - cx;
+        var by = 3 * (_y2 - _y1) - cy;
+        var ax = 1 - cx - bx;
+        var ay = 1 - cy - by;
+        var x = ax * Math.pow(t, 3) + bx * Math.pow(t, 2) + cx * t;
+        var y = ay * Math.pow(t, 3) + by * Math.pow(t, 2) + cy * t;
+        return [x, y];
+    }
+    function factorial$2(n) {
+        if (n === 0 || n === 1) {
+            return 1;
+        }
+        return n * factorial$2(n - 1);
+    }
+    function combination$2(n, k) {
+        return factorial$2(n) / (factorial$2(k) * factorial$2(n - k));
+    }
+    function NBezier$2(points, t) {
+        var n = points.length - 1;
+        var result = [0, 0];
+        for (var i = 0; i <= n; i++) {
+            var coefficient = combination$2(n, i) * Math.pow(1 - t, n - i) * Math.pow(t, i);
+            result[0] += coefficient * points[i][0];
+            result[1] += coefficient * points[i][1];
+        }
+        return result;
+    }
+    var animate$2 = {
+        AnimateFrame: AnimateFrame$2,
+        quadraticBezier: quadraticBezier$2,
+        cubicBezier: cubicBezier$2,
+        factorial: factorial$2,
+        combination: combination$2,
+        NBezier: NBezier$2,
+    };
+
+    var MessageCenter$2 = (function () {
+        function MessageCenter(options) {
+            if (options === void 0) { options = {}; }
+            this.options = options;
+            this.events = {};
+        }
+        MessageCenter.prototype.on = function (type, handler) {
+            this.checkHandler(type, handler);
+            var fns = this.getHandler(type, []);
+            fns.push(handler);
+            return this;
+        };
+        MessageCenter.prototype.emit = function (type, data) {
+            if (this.has(type)) {
+                this.runHandler(type, data);
+            }
+            return this;
+        };
+        MessageCenter.prototype.un = function (type, handler) {
+            this.unHandler(type, handler);
+            return this;
+        };
+        MessageCenter.prototype.once = function (type, handler) {
+            var _this = this;
+            this.checkHandler(type, handler);
+            var fn = function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                _this.un(type, fn);
+                return handler.apply(void 0, args);
+            };
+            this.on(type, fn);
+            return this;
+        };
+        MessageCenter.prototype.clear = function () {
+            this.events = {};
+            return this;
+        };
+        MessageCenter.prototype.has = function (type) {
+            return !!this.getHandler(type);
+        };
+        MessageCenter.prototype.getHandler = function (type, defaultVal) {
+            var _a;
+            typeof defaultVal === "object" && (this.events[type] = (_a = this.events[type]) !== null && _a !== void 0 ? _a : defaultVal);
+            return this.events[type];
+        };
+        MessageCenter.prototype.handlerLength = function (type) {
+            var _a, _b;
+            return (_b = (_a = this.getHandler(type)) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+        };
+        MessageCenter.prototype.watch = function (type, handler) {
+            var _this = this;
+            this.checkHandler(type, handler);
+            var fn = function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                _this.emit(_this.prefixStr(type), handler.apply(void 0, args));
+            };
+            this.on(type, fn);
+            return this;
+        };
+        MessageCenter.prototype.invoke = function (type, data) {
+            var _this = this;
+            return new Promise(function (resolve) {
+                _this.once(_this.prefixStr(type), resolve);
+                _this.emit(type, data);
+            });
+        };
+        MessageCenter.prototype.runHandler = function (type, data) {
+            var _fns = this.getHandler(type);
+            for (var _i = 0, _fns_1 = _fns; _i < _fns_1.length; _i++) {
+                var fn = _fns_1[_i];
+                fn && fn(data);
+            }
+        };
+        MessageCenter.prototype.unHandler = function (type, handler) {
+            var _fns = this.getHandler(type);
+            !handler && (this.events[type] = []);
+            handler && this.checkHandler(type, handler);
+            for (var i = 0; i < _fns.length; i++) {
+                if (_fns && _fns[i] === handler) {
+                    _fns[i] = null;
+                }
+            }
+        };
+        MessageCenter.prototype.prefixStr = function (str) {
+            return "@".concat(str);
+        };
+        MessageCenter.prototype.checkHandler = function (type, handler) {
+            var _a = this.options, _b = _a.blackList, blackList = _b === void 0 ? [] : _b, _c = _a.maxLen, maxLen = _c === void 0 ? Infinity : _c;
+            var len = this.handlerLength(type);
+            if ((type === null || type === void 0 ? void 0 : type.length) === 0) {
+                throw new Error('type.length can not be 0');
+            }
+            if (!handler || !type) {
+                throw new ReferenceError('type or handler is not defined');
+            }
+            if (typeof handler !== 'function' || typeof type !== 'string') {
+                throw new TypeError("".concat(handler, " is not a function or ").concat(type, " is not a string"));
+            }
+            if (blackList.includes(type)) {
+                throw new Error("".concat(type, " is not allow"));
+            }
+            if (maxLen <= len) {
+                throw new Error("the number of ".concat(type, " must be less than ").concat(maxLen));
+            }
+        };
+        MessageCenter.Instance = function (Fn) {
+            if (!Fn._instance) {
+                Object.defineProperty(Fn, "_instance", {
+                    value: new Fn()
+                });
+            }
+            return Fn._instance;
+        };
+        return MessageCenter;
+    }());
+    MessageCenter$2.Instance(MessageCenter$2);
+    var decoratorMessageCenter$2 = function (target) {
+        if (!target.prototype.messageCenter) {
+            target.prototype.messageCenter = new MessageCenter$2();
+        }
+        return target;
+    };
+
+    var __assign$7 = function () {
+        __assign$7 = Object.assign || function(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                    t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign$7.apply(this, arguments);
+    };
+    var __decorate$2 = function (decorators, target, key, desc) {
+        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+        if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+        else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+        return c > 3 && r && Object.defineProperty(target, key, r), r;
+    };
+    var __metadata$2 = function (k, v) {
+        if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+    };
+    var __awaiter$2 = function (thisArg, _arguments, P, generator) {
+        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+            step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+    };
+    var __generator$2 = function (thisArg, body) {
+        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+        function verb(n) { return function (v) { return step([n, v]); }; }
+        function step(op) {
+            if (f) throw new TypeError("Generator is already executing.");
+            while (g && (g = 0, op[0] && (_ = 0)), _) try {
+                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+                if (y = 0, t) op = [op[0] & 2, t.value];
+                switch (op[0]) {
+                    case 0: case 1: t = op; break;
+                    case 4: _.label++; return { value: op[1], done: false };
+                    case 5: _.label++; y = op[1]; op = [0]; continue;
+                    case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                    default:
+                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                        if (t[2]) _.ops.pop();
+                        _.trys.pop(); continue;
+                }
+                op = body.call(thisArg, _);
+            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+        }
+    };
+    var TaskQueue$2 = (function () {
+        function TaskQueue(props) {
+            var _this = this;
+            this.fix = "@~&$";
+            this.init = function () {
+                _this.messageCenter.on("push:handler", _this.run);
+                _this.messageCenter.on("run:success:handler", _this.run);
+                _this.messageCenter.on("run:success:handler", _this.finish);
+                _this.messageCenter.on("run:error:handler", _this.run);
+                _this.messageCenter.on("run:error:handler", _this.finish);
+            };
+            this.defineProps = function (props, key) {
+                Object.defineProperty(_this, key, { value: props });
+            };
+            this.push = function (queue) {
+                var _a;
+                _this.checkHandler(queue);
+                var resolve = (_a = _this.defer(), _a.resolve), reject = _a.reject, promise = _a.promise;
+                var queueName = _this.fixStr(queue.name);
+                _this.queues = _this.queues.concat(queue.children.map(function (defer) { return ({ defer: defer, name: queueName }); }));
+                _this.queueTemp[queueName] = __assign$7(__assign$7({}, queue), { result: [] });
+                _this.messageCenter.emit("push:handler", reject);
+                _this.messageCenter.on(queueName, resolve);
+                return promise;
+            };
+            this.unshift = function (length) {
+                return _this.queues.splice(0, length);
+            };
+            this.run = function (_a) {
+                var reject = _a.reject;
+                return __awaiter$2(_this, void 0, void 0, function () {
+                    var queues, res, error_1;
+                    var _b, _c;
+                    return __generator$2(this, function (_d) {
+                        switch (_d.label) {
+                            case 0:
+                                if (this.stateProxy() === 'pending')
+                                    return [2, void 0];
+                                if (this.queues.length === 0)
+                                    return [2, this.stateProxy("idle")];
+                                this.stateProxy("pending");
+                                queues = this.unshift((_c = (_b = this.props) === null || _b === void 0 ? void 0 : _b.maxLen) !== null && _c !== void 0 ? _c : 10);
+                                _d.label = 1;
+                            case 1:
+                                _d.trys.push([1, 3, , 4]);
+                                return [4, Promise.all(queues.map(function (item, i) { return item.defer().catch(function (error) { return error; }); }))];
+                            case 2:
+                                res = _d.sent();
+                                return [2, this.handlerSuccess({ res: res, queues: queues })];
+                            case 3:
+                                error_1 = _d.sent();
+                                return [2, this.handlerError({ reject: reject, error: error_1, queues: queues })];
+                            case 4: return [2];
+                        }
+                    });
+                });
+            };
+            this.clear = function () {
+                _this.queues = [];
+                _this.queueTemp = {};
+                _this.props = null;
+                _this.stateProxy("idle");
+                _this.messageCenter.clear();
+            };
+            this.finish = function (_a) {
+                var _b = _a.res, res = _b === void 0 ? [] : _b, queues = _a.queues, _c = _a.error, error = _c === void 0 ? 'err' : _c;
+                var queueTemp = _this.queueTemp;
+                queues.forEach(function (it, i) {
+                    var _a, _b, _c;
+                    var item = queueTemp[it.name];
+                    item === null || item === void 0 ? void 0 : item.result.push((_a = res[i]) !== null && _a !== void 0 ? _a : error);
+                    if (((_b = item === null || item === void 0 ? void 0 : item.result) === null || _b === void 0 ? void 0 : _b.length) === ((_c = item === null || item === void 0 ? void 0 : item.children) === null || _c === void 0 ? void 0 : _c.length)) {
+                        _this.messageCenter.emit(it.name, item === null || item === void 0 ? void 0 : item.result);
+                        queueTemp[it.name] = null;
+                    }
+                });
+            };
+            this.handlerSuccess = function (data) {
+                _this.stateProxy("fulfilled");
+                return _this.messageCenter.emit("run:success:handler", data);
+            };
+            this.handlerError = function (data) {
+                var reject = data.reject, error = data.error;
+                _this.stateProxy("rejected");
+                reject && typeof reject === "function" && reject(error);
+                return _this.messageCenter.emit("run:error:handler", data);
+            };
+            this.stateProxy = function (state) {
+                state && (_this.state = state);
+                return _this.state;
+            };
+            this.defer = function () {
+                var resolve, reject;
+                return {
+                    promise: new Promise(function (_resolve, _reject) {
+                        resolve = _resolve;
+                        reject = _reject;
+                    }),
+                    resolve: resolve,
+                    reject: reject
+                };
+            };
+            this.clear();
+            props && this.defineProps(props, "props");
+            this.init();
+        }
+        TaskQueue.prototype.checkHandler = function (queue) {
+            var _a, _b;
+            if (!queue) {
+                throw new ReferenceError('queue is not defined');
+            }
+            if (!(queue.children instanceof Array) || typeof queue !== "object") {
+                throw new TypeError("queue should be an object and queue.children should be an array");
+            }
+            var noFn = function (i) { return !i || typeof i !== "function"; };
+            if (((_a = queue.children) === null || _a === void 0 ? void 0 : _a.length) === 0)
+                throw new Error('queue.children.length can not be 0');
+            if ((_b = queue.children) === null || _b === void 0 ? void 0 : _b.find(function (i) { return noFn(i); }))
+                throw new Error('queueList should have defer');
+        };
+        TaskQueue.prototype.fixStr = function (str) {
+            return "".concat(this.fix).concat(str);
+        };
+        TaskQueue = __decorate$2([
+            decoratorMessageCenter$2,
+            __metadata$2("design:paramtypes", [Object])
+        ], TaskQueue);
+        return TaskQueue;
+    }());
+
+    __assign$1$1(__assign$1$1(__assign$1$1(__assign$1$1(__assign$1$1(__assign$1$1(__assign$1$1(__assign$1$1(__assign$1$1(__assign$1$1(__assign$1$1({}, object$2), base$2), array$2), __function$2), element$2), __static$2), event$2), storage$2), log$2), animate$2), { eventMessageCenter: MessageCenter$2, taskQueueLib: TaskQueue$2 });
+
+    /**
+     * @author Toru Nagashima <https://github.com/mysticatea>
+     * @copyright 2015 Toru Nagashima. All rights reserved.
+     * See LICENSE file in root directory for full license.
+     */
+    /**
+     * @typedef {object} PrivateData
+     * @property {EventTarget} eventTarget The event target.
+     * @property {{type:string}} event The original event object.
+     * @property {number} eventPhase The current event phase.
+     * @property {EventTarget|null} currentTarget The current event target.
+     * @property {boolean} canceled The flag to prevent default.
+     * @property {boolean} stopped The flag to stop propagation.
+     * @property {boolean} immediateStopped The flag to stop propagation immediately.
+     * @property {Function|null} passiveListener The listener if the current listener is passive. Otherwise this is null.
+     * @property {number} timeStamp The unix time.
+     * @private
+     */
+
+    /**
+     * Private data for event wrappers.
+     * @type {WeakMap<Event, PrivateData>}
+     * @private
+     */
+    const privateData$1 = new WeakMap();
+
+    /**
+     * Cache for wrapper classes.
+     * @type {WeakMap<Object, Function>}
+     * @private
+     */
+    const wrappers$1 = new WeakMap();
+
+    /**
+     * Get private data.
+     * @param {Event} event The event object to get private data.
+     * @returns {PrivateData} The private data of the event.
+     * @private
+     */
+    function pd$1(event) {
+        const retv = privateData$1.get(event);
+        console.assert(
+            retv != null,
+            "'this' is expected an Event object, but got",
+            event
+        );
+        return retv
+    }
+
+    /**
+     * https://dom.spec.whatwg.org/#set-the-canceled-flag
+     * @param data {PrivateData} private data.
+     */
+    function setCancelFlag$1(data) {
+        if (data.passiveListener != null) {
+            if (
+                typeof console !== "undefined" &&
+                typeof console.error === "function"
+            ) {
+                console.error(
+                    "Unable to preventDefault inside passive event listener invocation.",
+                    data.passiveListener
+                );
+            }
+            return
+        }
+        if (!data.event.cancelable) {
+            return
+        }
+
+        data.canceled = true;
+        if (typeof data.event.preventDefault === "function") {
+            data.event.preventDefault();
+        }
+    }
+
+    /**
+     * @see https://dom.spec.whatwg.org/#interface-event
+     * @private
+     */
+    /**
+     * The event wrapper.
+     * @constructor
+     * @param {EventTarget} eventTarget The event target of this dispatching.
+     * @param {Event|{type:string}} event The original event to wrap.
+     */
+    function Event$2(eventTarget, event) {
+        privateData$1.set(this, {
+            eventTarget,
+            event,
+            eventPhase: 2,
+            currentTarget: eventTarget,
+            canceled: false,
+            stopped: false,
+            immediateStopped: false,
+            passiveListener: null,
+            timeStamp: event.timeStamp || Date.now(),
+        });
+
+        // https://heycam.github.io/webidl/#Unforgeable
+        Object.defineProperty(this, "isTrusted", { value: false, enumerable: true });
+
+        // Define accessors
+        const keys = Object.keys(event);
+        for (let i = 0; i < keys.length; ++i) {
+            const key = keys[i];
+            if (!(key in this)) {
+                Object.defineProperty(this, key, defineRedirectDescriptor$1(key));
+            }
+        }
+    }
+
+    // Should be enumerable, but class methods are not enumerable.
+    Event$2.prototype = {
+        /**
+         * The type of this event.
+         * @type {string}
+         */
+        get type() {
+            return pd$1(this).event.type
+        },
+
+        /**
+         * The target of this event.
+         * @type {EventTarget}
+         */
+        get target() {
+            return pd$1(this).eventTarget
+        },
+
+        /**
+         * The target of this event.
+         * @type {EventTarget}
+         */
+        get currentTarget() {
+            return pd$1(this).currentTarget
+        },
+
+        /**
+         * @returns {EventTarget[]} The composed path of this event.
+         */
+        composedPath() {
+            const currentTarget = pd$1(this).currentTarget;
+            if (currentTarget == null) {
+                return []
+            }
+            return [currentTarget]
+        },
+
+        /**
+         * Constant of NONE.
+         * @type {number}
+         */
+        get NONE() {
+            return 0
+        },
+
+        /**
+         * Constant of CAPTURING_PHASE.
+         * @type {number}
+         */
+        get CAPTURING_PHASE() {
+            return 1
+        },
+
+        /**
+         * Constant of AT_TARGET.
+         * @type {number}
+         */
+        get AT_TARGET() {
+            return 2
+        },
+
+        /**
+         * Constant of BUBBLING_PHASE.
+         * @type {number}
+         */
+        get BUBBLING_PHASE() {
+            return 3
+        },
+
+        /**
+         * The target of this event.
+         * @type {number}
+         */
+        get eventPhase() {
+            return pd$1(this).eventPhase
+        },
+
+        /**
+         * Stop event bubbling.
+         * @returns {void}
+         */
+        stopPropagation() {
+            const data = pd$1(this);
+
+            data.stopped = true;
+            if (typeof data.event.stopPropagation === "function") {
+                data.event.stopPropagation();
+            }
+        },
+
+        /**
+         * Stop event bubbling.
+         * @returns {void}
+         */
+        stopImmediatePropagation() {
+            const data = pd$1(this);
+
+            data.stopped = true;
+            data.immediateStopped = true;
+            if (typeof data.event.stopImmediatePropagation === "function") {
+                data.event.stopImmediatePropagation();
+            }
+        },
+
+        /**
+         * The flag to be bubbling.
+         * @type {boolean}
+         */
+        get bubbles() {
+            return Boolean(pd$1(this).event.bubbles)
+        },
+
+        /**
+         * The flag to be cancelable.
+         * @type {boolean}
+         */
+        get cancelable() {
+            return Boolean(pd$1(this).event.cancelable)
+        },
+
+        /**
+         * Cancel this event.
+         * @returns {void}
+         */
+        preventDefault() {
+            setCancelFlag$1(pd$1(this));
+        },
+
+        /**
+         * The flag to indicate cancellation state.
+         * @type {boolean}
+         */
+        get defaultPrevented() {
+            return pd$1(this).canceled
+        },
+
+        /**
+         * The flag to be composed.
+         * @type {boolean}
+         */
+        get composed() {
+            return Boolean(pd$1(this).event.composed)
+        },
+
+        /**
+         * The unix time of this event.
+         * @type {number}
+         */
+        get timeStamp() {
+            return pd$1(this).timeStamp
+        },
+
+        /**
+         * The target of this event.
+         * @type {EventTarget}
+         * @deprecated
+         */
+        get srcElement() {
+            return pd$1(this).eventTarget
+        },
+
+        /**
+         * The flag to stop event bubbling.
+         * @type {boolean}
+         * @deprecated
+         */
+        get cancelBubble() {
+            return pd$1(this).stopped
+        },
+        set cancelBubble(value) {
+            if (!value) {
+                return
+            }
+            const data = pd$1(this);
+
+            data.stopped = true;
+            if (typeof data.event.cancelBubble === "boolean") {
+                data.event.cancelBubble = true;
+            }
+        },
+
+        /**
+         * The flag to indicate cancellation state.
+         * @type {boolean}
+         * @deprecated
+         */
+        get returnValue() {
+            return !pd$1(this).canceled
+        },
+        set returnValue(value) {
+            if (!value) {
+                setCancelFlag$1(pd$1(this));
+            }
+        },
+
+        /**
+         * Initialize this event object. But do nothing under event dispatching.
+         * @param {string} type The event type.
+         * @param {boolean} [bubbles=false] The flag to be possible to bubble up.
+         * @param {boolean} [cancelable=false] The flag to be possible to cancel.
+         * @deprecated
+         */
+        initEvent() {
+            // Do nothing.
+        },
+    };
+
+    // `constructor` is not enumerable.
+    Object.defineProperty(Event$2.prototype, "constructor", {
+        value: Event$2,
+        configurable: true,
+        writable: true,
+    });
+
+    // Ensure `event instanceof window.Event` is `true`.
+    if (typeof window !== "undefined" && typeof window.Event !== "undefined") {
+        Object.setPrototypeOf(Event$2.prototype, window.Event.prototype);
+
+        // Make association for wrappers.
+        wrappers$1.set(window.Event.prototype, Event$2);
+    }
+
+    /**
+     * Get the property descriptor to redirect a given property.
+     * @param {string} key Property name to define property descriptor.
+     * @returns {PropertyDescriptor} The property descriptor to redirect the property.
+     * @private
+     */
+    function defineRedirectDescriptor$1(key) {
+        return {
+            get() {
+                return pd$1(this).event[key]
+            },
+            set(value) {
+                pd$1(this).event[key] = value;
+            },
+            configurable: true,
+            enumerable: true,
+        }
+    }
+
+    /**
+     * Get the property descriptor to call a given method property.
+     * @param {string} key Property name to define property descriptor.
+     * @returns {PropertyDescriptor} The property descriptor to call the method property.
+     * @private
+     */
+    function defineCallDescriptor$1(key) {
+        return {
+            value() {
+                const event = pd$1(this).event;
+                return event[key].apply(event, arguments)
+            },
+            configurable: true,
+            enumerable: true,
+        }
+    }
+
+    /**
+     * Define new wrapper class.
+     * @param {Function} BaseEvent The base wrapper class.
+     * @param {Object} proto The prototype of the original event.
+     * @returns {Function} The defined wrapper class.
+     * @private
+     */
+    function defineWrapper$1(BaseEvent, proto) {
+        const keys = Object.keys(proto);
+        if (keys.length === 0) {
+            return BaseEvent
+        }
+
+        /** CustomEvent */
+        function CustomEvent(eventTarget, event) {
+            BaseEvent.call(this, eventTarget, event);
+        }
+
+        CustomEvent.prototype = Object.create(BaseEvent.prototype, {
+            constructor: { value: CustomEvent, configurable: true, writable: true },
+        });
+
+        // Define accessors.
+        for (let i = 0; i < keys.length; ++i) {
+            const key = keys[i];
+            if (!(key in BaseEvent.prototype)) {
+                const descriptor = Object.getOwnPropertyDescriptor(proto, key);
+                const isFunc = typeof descriptor.value === "function";
+                Object.defineProperty(
+                    CustomEvent.prototype,
+                    key,
+                    isFunc
+                        ? defineCallDescriptor$1(key)
+                        : defineRedirectDescriptor$1(key)
+                );
+            }
+        }
+
+        return CustomEvent
+    }
+
+    /**
+     * Get the wrapper class of a given prototype.
+     * @param {Object} proto The prototype of the original event to get its wrapper.
+     * @returns {Function} The wrapper class.
+     * @private
+     */
+    function getWrapper$1(proto) {
+        if (proto == null || proto === Object.prototype) {
+            return Event$2
+        }
+
+        let wrapper = wrappers$1.get(proto);
+        if (wrapper == null) {
+            wrapper = defineWrapper$1(getWrapper$1(Object.getPrototypeOf(proto)), proto);
+            wrappers$1.set(proto, wrapper);
+        }
+        return wrapper
+    }
+
+    /**
+     * Wrap a given event to management a dispatching.
+     * @param {EventTarget} eventTarget The event target of this dispatching.
+     * @param {Object} event The event to wrap.
+     * @returns {Event} The wrapper instance.
+     * @private
+     */
+    function wrapEvent$1(eventTarget, event) {
+        const Wrapper = getWrapper$1(Object.getPrototypeOf(event));
+        return new Wrapper(eventTarget, event)
+    }
+
+    /**
+     * Get the immediateStopped flag of a given event.
+     * @param {Event} event The event to get.
+     * @returns {boolean} The flag to stop propagation immediately.
+     * @private
+     */
+    function isStopped$1(event) {
+        return pd$1(event).immediateStopped
+    }
+
+    /**
+     * Set the current event phase of a given event.
+     * @param {Event} event The event to set current target.
+     * @param {number} eventPhase New event phase.
+     * @returns {void}
+     * @private
+     */
+    function setEventPhase$1(event, eventPhase) {
+        pd$1(event).eventPhase = eventPhase;
+    }
+
+    /**
+     * Set the current target of a given event.
+     * @param {Event} event The event to set current target.
+     * @param {EventTarget|null} currentTarget New current target.
+     * @returns {void}
+     * @private
+     */
+    function setCurrentTarget$1(event, currentTarget) {
+        pd$1(event).currentTarget = currentTarget;
+    }
+
+    /**
+     * Set a passive listener of a given event.
+     * @param {Event} event The event to set current target.
+     * @param {Function|null} passiveListener New passive listener.
+     * @returns {void}
+     * @private
+     */
+    function setPassiveListener$1(event, passiveListener) {
+        pd$1(event).passiveListener = passiveListener;
+    }
+
+    /**
+     * @typedef {object} ListenerNode
+     * @property {Function} listener
+     * @property {1|2|3} listenerType
+     * @property {boolean} passive
+     * @property {boolean} once
+     * @property {ListenerNode|null} next
+     * @private
+     */
+
+    /**
+     * @type {WeakMap<object, Map<string, ListenerNode>>}
+     * @private
+     */
+    const listenersMap$1 = new WeakMap();
+
+    // Listener types
+    const CAPTURE$1 = 1;
+    const BUBBLE$1 = 2;
+    const ATTRIBUTE$1 = 3;
+
+    /**
+     * Check whether a given value is an object or not.
+     * @param {any} x The value to check.
+     * @returns {boolean} `true` if the value is an object.
+     */
+    function isObject$1(x) {
+        return x !== null && typeof x === "object" //eslint-disable-line no-restricted-syntax
+    }
+
+    /**
+     * Get listeners.
+     * @param {EventTarget} eventTarget The event target to get.
+     * @returns {Map<string, ListenerNode>} The listeners.
+     * @private
+     */
+    function getListeners$1(eventTarget) {
+        const listeners = listenersMap$1.get(eventTarget);
+        if (listeners == null) {
+            throw new TypeError(
+                "'this' is expected an EventTarget object, but got another value."
+            )
+        }
+        return listeners
+    }
+
+    /**
+     * Get the property descriptor for the event attribute of a given event.
+     * @param {string} eventName The event name to get property descriptor.
+     * @returns {PropertyDescriptor} The property descriptor.
+     * @private
+     */
+    function defineEventAttributeDescriptor$1(eventName) {
+        return {
+            get() {
+                const listeners = getListeners$1(this);
+                let node = listeners.get(eventName);
+                while (node != null) {
+                    if (node.listenerType === ATTRIBUTE$1) {
+                        return node.listener
+                    }
+                    node = node.next;
+                }
+                return null
+            },
+
+            set(listener) {
+                if (typeof listener !== "function" && !isObject$1(listener)) {
+                    listener = null; // eslint-disable-line no-param-reassign
+                }
+                const listeners = getListeners$1(this);
+
+                // Traverse to the tail while removing old value.
+                let prev = null;
+                let node = listeners.get(eventName);
+                while (node != null) {
+                    if (node.listenerType === ATTRIBUTE$1) {
+                        // Remove old value.
+                        if (prev !== null) {
+                            prev.next = node.next;
+                        } else if (node.next !== null) {
+                            listeners.set(eventName, node.next);
+                        } else {
+                            listeners.delete(eventName);
+                        }
+                    } else {
+                        prev = node;
+                    }
+
+                    node = node.next;
+                }
+
+                // Add new value.
+                if (listener !== null) {
+                    const newNode = {
+                        listener,
+                        listenerType: ATTRIBUTE$1,
+                        passive: false,
+                        once: false,
+                        next: null,
+                    };
+                    if (prev === null) {
+                        listeners.set(eventName, newNode);
+                    } else {
+                        prev.next = newNode;
+                    }
+                }
+            },
+            configurable: true,
+            enumerable: true,
+        }
+    }
+
+    /**
+     * Define an event attribute (e.g. `eventTarget.onclick`).
+     * @param {Object} eventTargetPrototype The event target prototype to define an event attrbite.
+     * @param {string} eventName The event name to define.
+     * @returns {void}
+     */
+    function defineEventAttribute$1(eventTargetPrototype, eventName) {
+        Object.defineProperty(
+            eventTargetPrototype,
+            `on${eventName}`,
+            defineEventAttributeDescriptor$1(eventName)
+        );
+    }
+
+    /**
+     * Define a custom EventTarget with event attributes.
+     * @param {string[]} eventNames Event names for event attributes.
+     * @returns {EventTarget} The custom EventTarget.
+     * @private
+     */
+    function defineCustomEventTarget$1(eventNames) {
+        /** CustomEventTarget */
+        function CustomEventTarget() {
+            EventTarget$1.call(this);
+        }
+
+        CustomEventTarget.prototype = Object.create(EventTarget$1.prototype, {
+            constructor: {
+                value: CustomEventTarget,
+                configurable: true,
+                writable: true,
+            },
+        });
+
+        for (let i = 0; i < eventNames.length; ++i) {
+            defineEventAttribute$1(CustomEventTarget.prototype, eventNames[i]);
+        }
+
+        return CustomEventTarget
+    }
+
+    /**
+     * EventTarget.
+     *
+     * - This is constructor if no arguments.
+     * - This is a function which returns a CustomEventTarget constructor if there are arguments.
+     *
+     * For example:
+     *
+     *     class A extends EventTarget {}
+     *     class B extends EventTarget("message") {}
+     *     class C extends EventTarget("message", "error") {}
+     *     class D extends EventTarget(["message", "error"]) {}
+     */
+    function EventTarget$1() {
+        /*eslint-disable consistent-return */
+        if (this instanceof EventTarget$1) {
+            listenersMap$1.set(this, new Map());
+            return
+        }
+        if (arguments.length === 1 && Array.isArray(arguments[0])) {
+            return defineCustomEventTarget$1(arguments[0])
+        }
+        if (arguments.length > 0) {
+            const types = new Array(arguments.length);
+            for (let i = 0; i < arguments.length; ++i) {
+                types[i] = arguments[i];
+            }
+            return defineCustomEventTarget$1(types)
+        }
+        throw new TypeError("Cannot call a class as a function")
+        /*eslint-enable consistent-return */
+    }
+
+    // Should be enumerable, but class methods are not enumerable.
+    EventTarget$1.prototype = {
+        /**
+         * Add a given listener to this event target.
+         * @param {string} eventName The event name to add.
+         * @param {Function} listener The listener to add.
+         * @param {boolean|{capture?:boolean,passive?:boolean,once?:boolean}} [options] The options for this listener.
+         * @returns {void}
+         */
+        addEventListener(eventName, listener, options) {
+            if (listener == null) {
+                return
+            }
+            if (typeof listener !== "function" && !isObject$1(listener)) {
+                throw new TypeError("'listener' should be a function or an object.")
+            }
+
+            const listeners = getListeners$1(this);
+            const optionsIsObj = isObject$1(options);
+            const capture = optionsIsObj
+                ? Boolean(options.capture)
+                : Boolean(options);
+            const listenerType = capture ? CAPTURE$1 : BUBBLE$1;
+            const newNode = {
+                listener,
+                listenerType,
+                passive: optionsIsObj && Boolean(options.passive),
+                once: optionsIsObj && Boolean(options.once),
+                next: null,
+            };
+
+            // Set it as the first node if the first node is null.
+            let node = listeners.get(eventName);
+            if (node === undefined) {
+                listeners.set(eventName, newNode);
+                return
+            }
+
+            // Traverse to the tail while checking duplication..
+            let prev = null;
+            while (node != null) {
+                if (
+                    node.listener === listener &&
+                    node.listenerType === listenerType
+                ) {
+                    // Should ignore duplication.
+                    return
+                }
+                prev = node;
+                node = node.next;
+            }
+
+            // Add it.
+            prev.next = newNode;
+        },
+
+        /**
+         * Remove a given listener from this event target.
+         * @param {string} eventName The event name to remove.
+         * @param {Function} listener The listener to remove.
+         * @param {boolean|{capture?:boolean,passive?:boolean,once?:boolean}} [options] The options for this listener.
+         * @returns {void}
+         */
+        removeEventListener(eventName, listener, options) {
+            if (listener == null) {
+                return
+            }
+
+            const listeners = getListeners$1(this);
+            const capture = isObject$1(options)
+                ? Boolean(options.capture)
+                : Boolean(options);
+            const listenerType = capture ? CAPTURE$1 : BUBBLE$1;
+
+            let prev = null;
+            let node = listeners.get(eventName);
+            while (node != null) {
+                if (
+                    node.listener === listener &&
+                    node.listenerType === listenerType
+                ) {
+                    if (prev !== null) {
+                        prev.next = node.next;
+                    } else if (node.next !== null) {
+                        listeners.set(eventName, node.next);
+                    } else {
+                        listeners.delete(eventName);
+                    }
+                    return
+                }
+
+                prev = node;
+                node = node.next;
+            }
+        },
+
+        /**
+         * Dispatch a given event.
+         * @param {Event|{type:string}} event The event to dispatch.
+         * @returns {boolean} `false` if canceled.
+         */
+        dispatchEvent(event) {
+            if (event == null || typeof event.type !== "string") {
+                throw new TypeError('"event.type" should be a string.')
+            }
+
+            // If listeners aren't registered, terminate.
+            const listeners = getListeners$1(this);
+            const eventName = event.type;
+            let node = listeners.get(eventName);
+            if (node == null) {
+                return true
+            }
+
+            // Since we cannot rewrite several properties, so wrap object.
+            const wrappedEvent = wrapEvent$1(this, event);
+
+            // This doesn't process capturing phase and bubbling phase.
+            // This isn't participating in a tree.
+            let prev = null;
+            while (node != null) {
+                // Remove this listener if it's once
+                if (node.once) {
+                    if (prev !== null) {
+                        prev.next = node.next;
+                    } else if (node.next !== null) {
+                        listeners.set(eventName, node.next);
+                    } else {
+                        listeners.delete(eventName);
+                    }
+                } else {
+                    prev = node;
+                }
+
+                // Call this listener
+                setPassiveListener$1(
+                    wrappedEvent,
+                    node.passive ? node.listener : null
+                );
+                if (typeof node.listener === "function") {
+                    try {
+                        node.listener.call(this, wrappedEvent);
+                    } catch (err) {
+                        if (
+                            typeof console !== "undefined" &&
+                            typeof console.error === "function"
+                        ) {
+                            console.error(err);
+                        }
+                    }
+                } else if (
+                    node.listenerType !== ATTRIBUTE$1 &&
+                    typeof node.listener.handleEvent === "function"
+                ) {
+                    node.listener.handleEvent(wrappedEvent);
+                }
+
+                // Break if `event.stopImmediatePropagation` was called.
+                if (isStopped$1(wrappedEvent)) {
+                    break
+                }
+
+                node = node.next;
+            }
+            setPassiveListener$1(wrappedEvent, null);
+            setEventPhase$1(wrappedEvent, 0);
+            setCurrentTarget$1(wrappedEvent, null);
+
+            return !wrappedEvent.defaultPrevented
+        },
+    };
+
+    // `constructor` is not enumerable.
+    Object.defineProperty(EventTarget$1.prototype, "constructor", {
+        value: EventTarget$1,
+        configurable: true,
+        writable: true,
+    });
+
+    // Ensure `eventTarget instanceof window.EventTarget` is `true`.
+    if (
+        typeof window !== "undefined" &&
+        typeof window.EventTarget !== "undefined"
+    ) {
+        Object.setPrototypeOf(EventTarget$1.prototype, window.EventTarget.prototype);
+    }
+
+    /**
+     * @author Toru Nagashima <https://github.com/mysticatea>
+     * See LICENSE file in root directory for full license.
+     */
+
+    /**
+     * The signal class.
+     * @see https://dom.spec.whatwg.org/#abortsignal
+     */
+    let AbortSignal$1 = class AbortSignal extends EventTarget$1 {
+        /**
+         * AbortSignal cannot be constructed directly.
+         */
+        constructor() {
+            super();
+            throw new TypeError("AbortSignal cannot be constructed directly");
+        }
+        /**
+         * Returns `true` if this `AbortSignal`'s `AbortController` has signaled to abort, and `false` otherwise.
+         */
+        get aborted() {
+            const aborted = abortedFlags$1.get(this);
+            if (typeof aborted !== "boolean") {
+                throw new TypeError(`Expected 'this' to be an 'AbortSignal' object, but got ${this === null ? "null" : typeof this}`);
+            }
+            return aborted;
+        }
+    };
+    defineEventAttribute$1(AbortSignal$1.prototype, "abort");
+    /**
+     * Create an AbortSignal object.
+     */
+    function createAbortSignal$1() {
+        const signal = Object.create(AbortSignal$1.prototype);
+        EventTarget$1.call(signal);
+        abortedFlags$1.set(signal, false);
+        return signal;
+    }
+    /**
+     * Abort a given signal.
+     */
+    function abortSignal$1(signal) {
+        if (abortedFlags$1.get(signal) !== false) {
+            return;
+        }
+        abortedFlags$1.set(signal, true);
+        signal.dispatchEvent({ type: "abort" });
+    }
+    /**
+     * Aborted flag for each instances.
+     */
+    const abortedFlags$1 = new WeakMap();
+    // Properties should be enumerable.
+    Object.defineProperties(AbortSignal$1.prototype, {
+        aborted: { enumerable: true },
+    });
+    // `toString()` should return `"[object AbortSignal]"`
+    if (typeof Symbol === "function" && typeof Symbol.toStringTag === "symbol") {
+        Object.defineProperty(AbortSignal$1.prototype, Symbol.toStringTag, {
+            configurable: true,
+            value: "AbortSignal",
+        });
+    }
+
+    /**
+     * The AbortController.
+     * @see https://dom.spec.whatwg.org/#abortcontroller
+     */
+    let AbortController$2 = class AbortController {
+        /**
+         * Initialize this controller.
+         */
+        constructor() {
+            signals$1.set(this, createAbortSignal$1());
+        }
+        /**
+         * Returns the `AbortSignal` object associated with this object.
+         */
+        get signal() {
+            return getSignal$1(this);
+        }
+        /**
+         * Abort and signal to any observers that the associated activity is to be aborted.
+         */
+        abort() {
+            abortSignal$1(getSignal$1(this));
+        }
+    };
+    /**
+     * Associated signals.
+     */
+    const signals$1 = new WeakMap();
+    /**
+     * Get the associated signal of a given controller.
+     */
+    function getSignal$1(controller) {
+        const signal = signals$1.get(controller);
+        if (signal == null) {
+            throw new TypeError(`Expected 'this' to be an 'AbortController' object, but got ${controller === null ? "null" : typeof controller}`);
+        }
+        return signal;
+    }
+    // Properties should be enumerable.
+    Object.defineProperties(AbortController$2.prototype, {
+        signal: { enumerable: true },
+        abort: { enumerable: true },
+    });
+    if (typeof Symbol === "function" && typeof Symbol.toStringTag === "symbol") {
+        Object.defineProperty(AbortController$2.prototype, Symbol.toStringTag, {
+            configurable: true,
+            value: "AbortController",
+        });
+    }
+
+    /******************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+    /* global Reflect, Promise, SuppressedError, Symbol */
+
+    var extendStatics$1 = function(d, b) {
+        extendStatics$1 = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics$1(d, b);
+    };
+
+    function __extends$1(d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics$1(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    }
+
+    var __assign$6 = function() {
+        __assign$6 = Object.assign || function __assign(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign$6.apply(this, arguments);
+    };
+
+    function __rest$1(s, e) {
+        var t = {};
+        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+            t[p] = s[p];
+        if (s != null && typeof Object.getOwnPropertySymbols === "function")
+            for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+                if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                    t[p[i]] = s[p[i]];
+            }
+        return t;
+    }
+
+    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+
+    var CustomAbortController$1;
+    var httpRequest$1;
+    var httpsRequest$1;
+    var parse$1;
+    var hasAbort$1 = typeof AbortController !== "undefined";
+    if (typeof window !== 'undefined' || hasAbort$1) {
+        CustomAbortController$1 = globalThis.AbortController;
+    }
+    else if (typeof require !== "undefined") {
+        httpRequest$1 = require("http").request;
+        httpsRequest$1 = require("https").request;
+        parse$1 = require("url").parse;
+        CustomAbortController$1 = require('abort-controller');
+    }
+    else if (typeof globalThis === "object") {
+        httpRequest$1 = http.request;
+        httpsRequest$1 = https.request;
+        parse$1 = url.parse;
+        CustomAbortController$1 = AbortController$2;
+    }
+    else {
+        CustomAbortController$1 = function () {
+            throw new Error('AbortController is not defined');
+        };
+    }
+
+    var Interceptors$1 = (function () {
+        function Interceptors() {
+        }
+        Interceptors.prototype.use = function (type, fn) {
+            switch (type) {
+                case "request":
+                    this.requestSuccess = fn;
+                    break;
+                case "response":
+                    this.responseSuccess = fn;
+                    break;
+                case "error":
+                    this.error = fn;
+                    break;
+            }
+            return this;
+        };
+        Object.defineProperty(Interceptors.prototype, "reqFn", {
+            get: function () {
+                return this.requestSuccess;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(Interceptors.prototype, "resFn", {
+            get: function () {
+                return this.responseSuccess;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(Interceptors.prototype, "errFn", {
+            get: function () {
+                return this.error;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        return Interceptors;
+    }());
+    var RequestBase$1 = (function (_super) {
+        __extends$1(RequestBase, _super);
+        function RequestBase(origin) {
+            var _this = _super.call(this) || this;
+            _this.chackUrl = function (url) {
+                return url.startsWith('/');
+            };
+            _this.checkIsHttps = function (url) {
+                return url.startsWith('https');
+            };
+            _this.fixOrigin = function (fixStr) {
+                if (_this.chackUrl(fixStr))
+                    return _this.origin + fixStr;
+                return fixStr;
+            };
+            _this.envDesc = function () {
+                if (typeof Window !== "undefined") {
+                    return "Window";
+                }
+                return "Node";
+            };
+            _this.errorFn = function (reject) { return function (err) { var _a, _b; return reject((_b = (_a = _this.errFn) === null || _a === void 0 ? void 0 : _a.call(_this, err)) !== null && _b !== void 0 ? _b : err); }; };
+            _this.clearTimer = function (opts) { return !!opts.timer && (clearTimeout(opts.timer), opts.timer = null); };
+            _this.initAbort = function (params) {
+                var controller = params.controller, timer = params.timer, timeout = params.timeout;
+                !timer && (params.timer = setTimeout(function () { return controller.abort(); }, timeout));
+                return params;
+            };
+            _this.requestType = function () {
+                switch (_this.envDesc()) {
+                    case "Window":
+                        return _this.fetch;
+                    case "Node":
+                        return _this.http;
+                }
+            };
+            _this.getDataByType = function (type, response) {
+                switch (type) {
+                    case "text":
+                    case "json":
+                    case "blob":
+                    case "formData":
+                    case "arrayBuffer":
+                        return response[type]();
+                    default:
+                        return response['json']();
+                }
+            };
+            _this.formatBodyString = function (bodyString) {
+                return {
+                    text: function () { return bodyString; },
+                    json: function () { var _a; return (_a = stringToJson$2(bodyString)) !== null && _a !== void 0 ? _a : bodyString; },
+                    blob: function () { return stringToJson$2(bodyString); },
+                    formData: function () { return stringToJson$2(bodyString); },
+                    arrayBuffer: function () { return stringToJson$2(bodyString); },
+                };
+            };
+            _this.origin = origin !== null && origin !== void 0 ? origin : '';
+            return _this;
+        }
+        return RequestBase;
+    }(Interceptors$1));
+    var RequestInit$1 = (function (_super) {
+        __extends$1(RequestInit, _super);
+        function RequestInit(origin) {
+            var _this = _super.call(this, origin) || this;
+            _this.initDefaultParams = function (url, _a) {
+                var _b, _c;
+                var _d = _a.method, method = _d === void 0 ? "GET" : _d, _e = _a.query, query = _e === void 0 ? {} : _e, _f = _a.headers, headers = _f === void 0 ? {} : _f, _g = _a.body, body = _g === void 0 ? null : _g, _h = _a.timeout, timeout = _h === void 0 ? 30 * 1000 : _h, _j = _a.controller, controller = _j === void 0 ? new CustomAbortController$1() : _j, _k = _a.type, type = _k === void 0 ? "json" : _k, others = __rest$1(_a, ["method", "query", "headers", "body", "timeout", "controller", "type"]);
+                var __params = __assign$6({ url: url, method: method, query: query, headers: headers, body: method === "GET" ? null : jsonToString$2(body), timeout: timeout, signal: controller === null || controller === void 0 ? void 0 : controller.signal, controller: controller, type: type, timer: null }, others);
+                var params = (_c = (_b = _this.reqFn) === null || _b === void 0 ? void 0 : _b.call(_this, __params)) !== null && _c !== void 0 ? _c : __params;
+                params.url = urlJoin$2(_this.fixOrigin(url), __params.query);
+                return params;
+            };
+            _this.initFetchParams = function (url, opts) {
+                var _temp = _this.initAbort(_this.initDefaultParams(url, opts));
+                return _temp;
+            };
+            _this.initHttpParams = function (url, opts) {
+                var _temp = _this.initAbort(_this.initDefaultParams(url, opts));
+                var options = parse$1(_temp.url, true);
+                return __assign$6(__assign$6({}, _temp), options);
+            };
+            return _this;
+        }
+        return RequestInit;
+    }(RequestBase$1));
+    var Request$1 = (function (_super) {
+        __extends$1(Request, _super);
+        function Request(origin) {
+            var _this = _super.call(this, origin) || this;
+            _this.fetch = function (_url, _opts) {
+                var _a = defer$2(), promise = _a.promise, resolve = _a.resolve, reject = _a.reject;
+                var _b = _this.initFetchParams(_url, _opts), url = _b.url, opts = __rest$1(_b, ["url"]);
+                var signal = opts.signal;
+                promise.finally(function () { return _this.clearTimer(opts); });
+                signal.addEventListener('abort', function () { return _this.errorFn(reject); });
+                fetch(url, opts).then(function (response) {
+                    if ((response === null || response === void 0 ? void 0 : response.status) >= 200 && (response === null || response === void 0 ? void 0 : response.status) < 300) {
+                        return _this.getDataByType(opts.type, response);
+                    }
+                    return _this.errorFn(reject);
+                }).then(function (res) { var _a, _b; return resolve((_b = (_a = _this.resFn) === null || _a === void 0 ? void 0 : _a.call(_this, res)) !== null && _b !== void 0 ? _b : res); }).catch(_this.errorFn(reject));
+                return promise;
+            };
+            _this.http = function (_url, _opts) {
+                var _a = defer$2(), promise = _a.promise, resolve = _a.resolve, reject = _a.reject;
+                var params = _this.initHttpParams(_url, _opts);
+                var signal = params.signal, url = params.url, body = params.body;
+                promise.finally(function () { return _this.clearTimer(params); });
+                var request = _this.checkIsHttps(url) ? httpsRequest$1 : httpRequest$1;
+                var req = request(params, function (response) {
+                    var statusCode = response.statusCode, statusMessage = response.statusMessage;
+                    var data = "";
+                    response.setEncoding('utf8');
+                    response.on('data', function (chunk) { return data += chunk; });
+                    return response.on("end", function () {
+                        var _a, _b;
+                        var result = _this.getDataByType(params.type, _this.formatBodyString(data));
+                        if (statusCode >= 200 && statusCode < 300) {
+                            return resolve((_b = (_a = _this.resFn) === null || _a === void 0 ? void 0 : _a.call(_this, result)) !== null && _b !== void 0 ? _b : result);
+                        }
+                        return _this.errorFn(reject)({ statusCode: statusCode, statusMessage: statusMessage, result: result, data: data });
+                    });
+                });
+                signal.addEventListener('abort', function () { return _this.errorFn(reject)(req.destroy(new Error('request timeout'))); });
+                body && req.write(body);
+                req.on('error', _this.errorFn(reject));
+                req.end();
+                return promise;
+            };
+            _this.GET = function (url, query, _, opts) { return _this.request(url, __assign$6({ query: query, method: "GET" }, opts)); };
+            _this.POST = function (url, query, body, opts) { return _this.request(url, __assign$6({ query: query, method: "POST", body: body }, opts)); };
+            _this.PUT = function (url, query, body, opts) { return _this.request(url, __assign$6({ query: query, method: "PUT", body: body }, opts)); };
+            _this.DELETE = function (url, query, body, opts) { return _this.request(url, __assign$6({ query: query, method: "DELETE", body: body }, opts)); };
+            _this.OPTIONS = function (url, query, body, opts) { return _this.request(url, __assign$6({ query: query, method: "OPTIONS", body: body }, opts)); };
+            _this.HEAD = function (url, query, body, opts) { return _this.request(url, __assign$6({ query: query, method: "HEAD", body: body }, opts)); };
+            _this.PATCH = function (url, query, body, opts) { return _this.request(url, __assign$6({ query: query, method: "PATCH", body: body }, opts)); };
+            _this.request = _this.requestType();
+            return _this;
+        }
+        return Request;
+    }(RequestInit$1));
+
+    /******************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+
     var __assign$4 = function() {
         __assign$4 = Object.assign || function __assign(t) {
             for (var s, i = 1, n = arguments.length; i < n; i++) {
@@ -40,7 +3032,7 @@
         return to.concat(ar || Array.prototype.slice.call(from));
     }
 
-    exports.types = void 0;
+    var types$1;
     (function (types) {
         types["[object Array]"] = "array";
         types["[object Object]"] = "object";
@@ -52,8 +3044,8 @@
         types["[object Date]"] = "date";
         types["[object RegExp]"] = "regExp";
         types["[object Math]"] = "math";
-    })(exports.types || (exports.types = {}));
-    var __static$1 = { types: exports.types };
+    })(types$1 || (types$1 = {}));
+    var __static$1 = { types: types$1 };
 
     var randomNum$1 = function (min, max, bool) {
         if (bool === void 0) { bool = false; }
@@ -86,7 +3078,7 @@
         }
         else if (type === "object") {
             var key = Object.prototype.toString.call(data);
-            return exports.types[key];
+            return types$1[key];
         }
         return type;
     };
@@ -690,7 +3682,7 @@
         };
         return MessageCenter;
     }());
-    var messageCenter = MessageCenter$1.Instance(MessageCenter$1);
+    MessageCenter$1.Instance(MessageCenter$1);
     var decoratorMessageCenter$1 = function (target) {
         if (!target.prototype.messageCenter) {
             target.prototype.messageCenter = new MessageCenter$1();
@@ -698,7 +3690,7 @@
         return target;
     };
 
-    var __assign$3 = (undefined && undefined.__assign) || function () {
+    var __assign$3 = function () {
         __assign$3 = Object.assign || function(t) {
             for (var s, i = 1, n = arguments.length; i < n; i++) {
                 s = arguments[i];
@@ -709,16 +3701,16 @@
         };
         return __assign$3.apply(this, arguments);
     };
-    var __decorate$1 = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+    var __decorate$1 = function (decorators, target, key, desc) {
         var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
         if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
         else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
         return c > 3 && r && Object.defineProperty(target, key, r), r;
     };
-    var __metadata$1 = (undefined && undefined.__metadata) || function (k, v) {
+    var __metadata$1 = function (k, v) {
         if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
     };
-    var __awaiter$1 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    var __awaiter$1 = function (thisArg, _arguments, P, generator) {
         function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
         return new (P || (P = Promise))(function (resolve, reject) {
             function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
@@ -727,7 +3719,7 @@
             step((generator = generator.apply(thisArg, _arguments || [])).next());
         });
     };
-    var __generator$1 = (undefined && undefined.__generator) || function (thisArg, body) {
+    var __generator$1 = function (thisArg, body) {
         var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
         return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
         function verb(n) { return function (v) { return step([n, v]); }; }
@@ -883,13 +3875,6 @@
         ], TaskQueue);
         return TaskQueue;
     }());
-    var decoratorTaskQueue = function (opts) {
-        return function (target) {
-            if (!target.prototype.taskQueue) {
-                target.prototype.taskQueue = new TaskQueue$1(opts);
-            }
-        };
-    };
 
     /******************************************************************************
     Copyright (c) Microsoft Corporation.
@@ -2752,15 +5737,15 @@
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     }
 
-    var __assign = function() {
-        __assign = Object.assign || function __assign(t) {
+    var __assign$5 = function() {
+        __assign$5 = Object.assign || function __assign(t) {
             for (var s, i = 1, n = arguments.length; i < n; i++) {
                 s = arguments[i];
                 for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
             }
             return t;
         };
-        return __assign.apply(this, arguments);
+        return __assign$5.apply(this, arguments);
     };
 
     function __rest(s, e) {
@@ -2915,7 +5900,7 @@
             _this.initDefaultParams = function (url, _a) {
                 var _b, _c;
                 var _d = _a.method, method = _d === void 0 ? "GET" : _d, _e = _a.query, query = _e === void 0 ? {} : _e, _f = _a.headers, headers = _f === void 0 ? {} : _f, _g = _a.body, body = _g === void 0 ? null : _g, _h = _a.timeout, timeout = _h === void 0 ? 30 * 1000 : _h, _j = _a.controller, controller = _j === void 0 ? new CustomAbortController() : _j, _k = _a.type, type = _k === void 0 ? "json" : _k, others = __rest(_a, ["method", "query", "headers", "body", "timeout", "controller", "type"]);
-                var __params = __assign({ url: url, method: method, query: query, headers: headers, body: method === "GET" ? null : jsonToString(body), timeout: timeout, signal: controller === null || controller === void 0 ? void 0 : controller.signal, controller: controller, type: type, timer: null }, others);
+                var __params = __assign$5({ url: url, method: method, query: query, headers: headers, body: method === "GET" ? null : jsonToString(body), timeout: timeout, signal: controller === null || controller === void 0 ? void 0 : controller.signal, controller: controller, type: type, timer: null }, others);
                 var params = (_c = (_b = _this.reqFn) === null || _b === void 0 ? void 0 : _b.call(_this, __params)) !== null && _c !== void 0 ? _c : __params;
                 params.url = urlJoin(_this.fixOrigin(url), __params.query);
                 return params;
@@ -2927,7 +5912,7 @@
             _this.initHttpParams = function (url, opts) {
                 var _temp = _this.initAbort(_this.initDefaultParams(url, opts));
                 var options = parse(_temp.url, true);
-                return __assign(__assign({}, _temp), options);
+                return __assign$5(__assign$5({}, _temp), options);
             };
             return _this;
         }
@@ -2977,72 +5962,196 @@
                 req.end();
                 return promise;
             };
-            _this.GET = function (url, query, _, opts) { return _this.request(url, __assign({ query: query, method: "GET" }, opts)); };
-            _this.POST = function (url, query, body, opts) { return _this.request(url, __assign({ query: query, method: "POST", body: body }, opts)); };
-            _this.PUT = function (url, query, body, opts) { return _this.request(url, __assign({ query: query, method: "PUT", body: body }, opts)); };
-            _this.DELETE = function (url, query, body, opts) { return _this.request(url, __assign({ query: query, method: "DELETE", body: body }, opts)); };
-            _this.OPTIONS = function (url, query, body, opts) { return _this.request(url, __assign({ query: query, method: "OPTIONS", body: body }, opts)); };
-            _this.HEAD = function (url, query, body, opts) { return _this.request(url, __assign({ query: query, method: "HEAD", body: body }, opts)); };
-            _this.PATCH = function (url, query, body, opts) { return _this.request(url, __assign({ query: query, method: "PATCH", body: body }, opts)); };
+            _this.GET = function (url, query, _, opts) { return _this.request(url, __assign$5({ query: query, method: "GET" }, opts)); };
+            _this.POST = function (url, query, body, opts) { return _this.request(url, __assign$5({ query: query, method: "POST", body: body }, opts)); };
+            _this.PUT = function (url, query, body, opts) { return _this.request(url, __assign$5({ query: query, method: "PUT", body: body }, opts)); };
+            _this.DELETE = function (url, query, body, opts) { return _this.request(url, __assign$5({ query: query, method: "DELETE", body: body }, opts)); };
+            _this.OPTIONS = function (url, query, body, opts) { return _this.request(url, __assign$5({ query: query, method: "OPTIONS", body: body }, opts)); };
+            _this.HEAD = function (url, query, body, opts) { return _this.request(url, __assign$5({ query: query, method: "HEAD", body: body }, opts)); };
+            _this.PATCH = function (url, query, body, opts) { return _this.request(url, __assign$5({ query: query, method: "PATCH", body: body }, opts)); };
             _this.request = _this.requestType();
             return _this;
         }
         return Request;
     }(RequestInit));
 
-    var index = __assign$4(__assign$4(__assign$4(__assign$4(__assign$4(__assign$4(__assign$4(__assign$4(__assign$4(__assign$4(__assign$4({}, object$1), base$1), array$1), __function$1), element$1), __static$1), event$1), storage$1), log$1), animate$1), { eventMessageCenter: MessageCenter$1, taskQueueLib: TaskQueue$1, JSRequest: Request });
-
-    exports.AnimateFrame = AnimateFrame$1;
-    exports.MessageCenter = MessageCenter$1;
-    exports.NBezier = NBezier$1;
-    exports.Request = Request;
-    exports.TaskQueue = TaskQueue$1;
-    exports.addHandler = addHandler$1;
-    exports.arrayDemote = arrayDemote$1;
-    exports.arrayRandom = arrayRandom$1;
-    exports.arrayUniq = arrayUniq$1;
-    exports.catchAwait = catchAwait$1;
-    exports.classDecorator = classDecorator$1;
-    exports.clearStorage = clearStorage$1;
-    exports.cloneDeep = cloneDeep$1;
-    exports.combination = combination$1;
-    exports.createElement = createElement$1;
-    exports.createObject = createObject$1;
-    exports.createObjectVariable = createObjectVariable$1;
-    exports.cubicBezier = cubicBezier$1;
-    exports.debounce = debounce$1;
-    exports.decoratorMessageCenter = decoratorMessageCenter$1;
+    __assign$4(__assign$4(__assign$4(__assign$4(__assign$4(__assign$4(__assign$4(__assign$4(__assign$4(__assign$4(__assign$4({}, object$1), base$1), array$1), __function$1), element$1), __static$1), event$1), storage$1), log$1), animate$1), { eventMessageCenter: MessageCenter$1, taskQueueLib: TaskQueue$1, JSRequest: Request });
+
+    /******************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+    /* global Reflect, Promise, SuppressedError, Symbol */
+
+
+    var __assign = function() {
+        __assign = Object.assign || function __assign(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign.apply(this, arguments);
+    };
+
+    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+
+    var defaultOptions = {
+        type: "interval",
+        autoStop: true
+    };
+    var TimerManager = (function () {
+        function TimerManager(opts) {
+            var _this = this;
+            this.__id = 0;
+            this.timers = {};
+            this.fixString = "#@$&*";
+            this.isFrame = function () { return _this.opts.type === "frame"; };
+            this.opts = __assign(__assign({}, defaultOptions), opts);
+        }
+        TimerManager.prototype.add = function (handle, delay) {
+            this.initDelay(delay);
+            return this.pushTimer(handle, delay);
+        };
+        TimerManager.prototype.delete = function (timer) {
+            var _a;
+            var id = timer.id, delay = timer.delay;
+            var timers = this.timers;
+            if (delay && ((_a = timers[delay]) === null || _a === void 0 ? void 0 : _a.handles))
+                timers[delay].handles = timers[delay].handles.filter(function (it) { return it.id !== id; });
+        };
+        TimerManager.prototype.clear = function () {
+            var _this = this;
+            var timers = this.timers;
+            Object.keys(timers).forEach(function (d) { return _this.stopTimer(timers[d]); });
+            this.timers = {};
+        };
+        TimerManager.prototype.pushTimer = function (handle, delay) {
+            var timers = this.timers;
+            var __info = {
+                id: this.getId(),
+                handle: handle,
+                delay: delay,
+            };
+            timers[delay].handles.push(__info);
+            return __info;
+        };
+        TimerManager.prototype.initDelay = function (delay) {
+            var timers = this.timers;
+            var timer = timers[delay];
+            if (timer)
+                return;
+            timers[delay] = {
+                intervalId: null,
+                handles: [],
+                delay: delay,
+            };
+            this.startTimer(timers[delay]);
+        };
+        TimerManager.prototype.startTimer = function (timer) {
+            var _this = this;
+            timer.intervalId = this.delayHandle(function () {
+                _this.autoStopTimer(timer);
+                timer.handles.forEach(function (it) { return it.handle(); });
+            }, timer.delay);
+        };
+        TimerManager.prototype.stopTimer = function (timer) {
+            var intervalId = timer.intervalId;
+            if (this.isFrame())
+                intervalId();
+            else
+                clearInterval(intervalId);
+        };
+        TimerManager.prototype.autoStopTimer = function (timer) {
+            var _a = this, autoStop = _a.opts.autoStop, timers = _a.timers;
+            var delay = timer.delay;
+            if (autoStop && timer.handles.length <= 0) {
+                this.stopTimer(timer);
+                timers[delay] = null;
+            }
+        };
+        TimerManager.prototype.delayHandle = function (handle, delay) {
+            if (this.isFrame())
+                return requestFrame(handle, delay);
+            else
+                return setInterval(handle, delay);
+        };
+        TimerManager.prototype.getId = function () {
+            return "".concat(this.fixString, "-").concat(++this.__id);
+        };
+        return TimerManager;
+    }());
+
+    var index = __assign$9(__assign$9(__assign$9(__assign$9(__assign$9(__assign$9(__assign$9(__assign$9(__assign$9(__assign$9(__assign$9({}, object$3), base$3), array$3), __function$3), element$3), __static$3), event$3), storage$3), log$3), animate$3), { eventMessageCenter: MessageCenter$3, taskQueueLib: TaskQueue$3, JSRequest: Request$1, TimerManager: TimerManager });
+
+    exports.AnimateFrame = AnimateFrame$3;
+    exports.MessageCenter = MessageCenter$3;
+    exports.NBezier = NBezier$3;
+    exports.Request = Request$1;
+    exports.TaskQueue = TaskQueue$3;
+    exports.TimerManager = TimerManager;
+    exports.addHandler = addHandler$3;
+    exports.arrayDemote = arrayDemote$3;
+    exports.arrayRandom = arrayRandom$3;
+    exports.arrayUniq = arrayUniq$3;
+    exports.catchAwait = catchAwait$3;
+    exports.classDecorator = classDecorator$3;
+    exports.clearStorage = clearStorage$3;
+    exports.cloneDeep = cloneDeep$3;
+    exports.combination = combination$3;
+    exports.createElement = createElement$3;
+    exports.createObject = createObject$3;
+    exports.createObjectVariable = createObjectVariable$3;
+    exports.cubicBezier = cubicBezier$3;
+    exports.debounce = debounce$3;
+    exports.decoratorMessageCenter = decoratorMessageCenter$3;
     exports.decoratorTaskQueue = decoratorTaskQueue;
     exports.default = index;
-    exports.defer = defer$1;
-    exports.dispatchEvent = dispatchEvent$1;
-    exports.enumInversion = enumInversion$1;
-    exports.factorial = factorial$1;
-    exports.getInstance = getInstance$1;
-    exports.getStorage = getStorage$1;
-    exports.getType = getType$1;
-    exports.getTypeByList = getTypeByList$1;
-    exports.getValue = getValue$1;
-    exports.inherit = inherit$1;
-    exports.isNotObject = isNotObject$1;
-    exports.isWindow = isWindow$1;
-    exports.jsonToString = jsonToString$1;
-    exports.logLoop = logLoop$1;
-    exports.logOneLine = logOneLine$1;
+    exports.defaultOptions = defaultOptions;
+    exports.defer = defer$3;
+    exports.dispatchEvent = dispatchEvent$3;
+    exports.emptyObject = emptyObject;
+    exports.enumInversion = enumInversion$3;
+    exports.factorial = factorial$3;
+    exports.getInstance = getInstance$3;
+    exports.getStorage = getStorage$3;
+    exports.getType = getType$3;
+    exports.getTypeByList = getTypeByList$3;
+    exports.getValue = getValue$3;
+    exports.inherit = inherit$3;
+    exports.isNotObject = isNotObject$3;
+    exports.isWindow = isWindow$3;
+    exports.jsonToString = jsonToString$3;
+    exports.logLoop = logLoop$3;
+    exports.logOneLine = logOneLine$3;
     exports.messageCenter = messageCenter;
-    exports.mixIn = mixIn$1;
-    exports.quadraticBezier = quadraticBezier$1;
-    exports.randomNum = randomNum$1;
-    exports.removeHandler = removeHandler$1;
-    exports.requestFrame = requestFrame;
-    exports.setStorage = setStorage$1;
-    exports.setValue = setValue$1;
-    exports.stopBubble = stopBubble$1;
-    exports.stopDefault = stopDefault$1;
-    exports.stringToJson = stringToJson$1;
-    exports.throttle = throttle$1;
-    exports.urlJoin = urlJoin$1;
-    exports.urlSplit = urlSplit$1;
+    exports.mixIn = mixIn$3;
+    exports.quadraticBezier = quadraticBezier$3;
+    exports.randomNum = randomNum$3;
+    exports.removeHandler = removeHandler$3;
+    exports.requestFrame = requestFrame$1;
+    exports.setStorage = setStorage$3;
+    exports.setValue = setValue$3;
+    exports.stopBubble = stopBubble$3;
+    exports.stopDefault = stopDefault$3;
+    exports.stringToJson = stringToJson$3;
+    exports.throttle = throttle$3;
+    exports.urlJoin = urlJoin$3;
+    exports.urlSplit = urlSplit$3;
 
     Object.defineProperty(exports, '__esModule', { value: true });