初始化

uni_modules/UniDevTools/node_modules/licia/$.d.ts

@@ -0,0 +1,51 @@
+import Select = require('./Select');
+import $offset = require('./$offset');
+import last = require('./last');
+import types = require('./types');
+
+declare namespace $ {
+    class $ extends Select {
+        find(selector: string): $;
+        each(fn: types.AnyFn): $;
+        offset(): $offset.IOffset;
+        hide(): $;
+        show(): $;
+        first(): $;
+        last(): $;
+        get(index: number): Element;
+        eq(index: number): $;
+        on(event: string, selector: string, handler: types.AnyFn): $;
+        on(event: string, handler: types.AnyFn): $;
+        off(event: string, selector: string, handler: types.AnyFn): $;
+        off(event: string, handler: types.AnyFn): $;
+        html(): string;
+        html(value: string): $;
+        text(): string;
+        text(value: string): $;
+        val(): string;
+        val(value: string): $;
+        css(name: string): string;
+        css(name: string, value: string): $;
+        css(properties: types.PlainObj<string | number>): $;
+        attr(name: string): string;
+        attr(name: string, value: string): $;
+        attr(attributes: types.PlainObj<string>): $;
+        data(name: string): string;
+        data(name: string, value: string): $;
+        data(attributes: types.PlainObj<string>): $;
+        rmAttr(name: string): $;
+        remove(): $;
+        addClass(name: string | string[]): $;
+        rmClass(name: string): $;
+        toggleClass(name: string): $;
+        hasClass(name: string): boolean;
+        parent(): $;
+        append(content: string | Element): $;
+        prepend(content: string | Element): $;
+        before(content: string | Element): $;
+        after(content: string | Element): $;
+    }
+}
+declare function $(selector: string | Element | Document): $.$;
+
+export = $;

uni_modules/UniDevTools/node_modules/licia/$.js

@@ -0,0 +1,126 @@
+var Select = require('./Select');
+var $offset = require('./$offset');
+var $show = require('./$show');
+var $css = require('./$css');
+var $attr = require('./$attr');
+var $property = require('./$property');
+var last = require('./last');
+var $remove = require('./$remove');
+var $data = require('./$data');
+var $event = require('./$event');
+var $class = require('./$class');
+var $insert = require('./$insert');
+var isUndef = require('./isUndef');
+var isStr = require('./isStr');
+exports = function(selector) {
+    return new Select(selector);
+};
+Select.methods({
+    offset: function() {
+        return $offset(this);
+    },
+    hide: function() {
+        return this.css('display', 'none');
+    },
+    show: function() {
+        $show(this);
+        return this;
+    },
+    first: function() {
+        return exports(this[0]);
+    },
+    last: function() {
+        return exports(last(this));
+    },
+    get: function(idx) {
+        return this[idx];
+    },
+    eq: function(idx) {
+        return exports(this[idx]);
+    },
+    on: function(event, selector, handler) {
+        $event.on(this, event, selector, handler);
+        return this;
+    },
+    off: function(event, selector, handler) {
+        $event.off(this, event, selector, handler);
+        return this;
+    },
+    html: function(val) {
+        var result = $property.html(this, val);
+        if (isUndef(val)) return result;
+        return this;
+    },
+    text: function(val) {
+        var result = $property.text(this, val);
+        if (isUndef(val)) return result;
+        return this;
+    },
+    val: function(val) {
+        var result = $property.val(this, val);
+        if (isUndef(val)) return result;
+        return this;
+    },
+    css: function(name, val) {
+        var result = $css(this, name, val);
+        if (isGetter(name, val)) return result;
+        return this;
+    },
+    attr: function(name, val) {
+        var result = $attr(this, name, val);
+        if (isGetter(name, val)) return result;
+        return this;
+    },
+    data: function(name, val) {
+        var result = $data(this, name, val);
+        if (isGetter(name, val)) return result;
+        return this;
+    },
+    rmAttr: function(name) {
+        $attr.remove(this, name);
+        return this;
+    },
+    remove: function() {
+        $remove(this);
+        return this;
+    },
+    addClass: function(name) {
+        $class.add(this, name);
+        return this;
+    },
+    rmClass: function(name) {
+        $class.remove(this, name);
+        return this;
+    },
+    toggleClass: function(name) {
+        $class.toggle(this, name);
+        return this;
+    },
+    hasClass: function(name) {
+        return $class.has(this, name);
+    },
+    parent: function() {
+        return exports(this[0].parentNode);
+    },
+    append: function(val) {
+        $insert.append(this, val);
+        return this;
+    },
+    prepend: function(val) {
+        $insert.prepend(this, val);
+        return this;
+    },
+    before: function(val) {
+        $insert.before(this, val);
+        return this;
+    },
+    after: function(val) {
+        $insert.after(this, val);
+        return this;
+    }
+});
+var isGetter = function(name, val) {
+    return isUndef(val) && isStr(name);
+};
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/$attr.d.ts

@@ -0,0 +1,14 @@
+import $safeEls = require('./$safeEls');
+import types = require('./types');
+
+declare namespace $attr {
+    function remove(element: $safeEls.El, name: string): void;
+}
+declare function $attr(element: $safeEls.El, name: string, value: string): void;
+declare function $attr(
+    element: $safeEls.El,
+    attributes: types.PlainObj<string>
+): void;
+declare function $attr(element: $safeEls.El, name: string): string;
+
+export = $attr;

uni_modules/UniDevTools/node_modules/licia/$attr.js

@@ -0,0 +1,38 @@
+var toArr = require('./toArr');
+var isObj = require('./isObj');
+var isStr = require('./isStr');
+var each = require('./each');
+var isUndef = require('./isUndef');
+var $safeEls = require('./$safeEls');
+exports = function(els, name, val) {
+    els = $safeEls(els);
+    var isGetter = isUndef(val) && isStr(name);
+    if (isGetter) return getAttr(els[0], name);
+    var attrs = name;
+    if (!isObj(attrs)) {
+        attrs = {};
+        attrs[name] = val;
+    }
+    setAttr(els, attrs);
+};
+exports.remove = function(els, names) {
+    els = $safeEls(els);
+    names = toArr(names);
+    each(els, function(node) {
+        each(names, function(name) {
+            node.removeAttribute(name);
+        });
+    });
+};
+function getAttr(el, name) {
+    return el.getAttribute(name);
+}
+function setAttr(els, attrs) {
+    each(els, function(el) {
+        each(attrs, function(val, name) {
+            el.setAttribute(name, val);
+        });
+    });
+}
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/$class.d.ts

@@ -0,0 +1,10 @@
+import $safeEls = require('./$safeEls');
+
+declare const $class: {
+    add(element: $safeEls.El, name: string | string[]): void;
+    has(element: $safeEls.El, name: string): boolean;
+    toggle(element: $safeEls.El, name: string): void;
+    remove(element: $safeEls.El, name: string): void;
+};
+
+export = $class;

uni_modules/UniDevTools/node_modules/licia/$class.js

@@ -0,0 +1,48 @@
+var toArr = require('./toArr');
+var some = require('./some');
+var $safeEls = require('./$safeEls');
+var isStr = require('./isStr');
+var each = require('./each');
+exports = {
+    add: function(els, name) {
+        els = $safeEls(els);
+        var names = safeName(name);
+        each(els, function(el) {
+            var classList = [];
+            each(names, function(name) {
+                if (!exports.has(el, name)) classList.push(name);
+            });
+            if (classList.length !== 0) {
+                el.className += (el.className ? ' ' : '') + classList.join(' ');
+            }
+        });
+    },
+    has: function(els, name) {
+        els = $safeEls(els);
+        var regName = new RegExp('(^|\\s)' + name + '(\\s|$)');
+        return some(els, function(el) {
+            return regName.test(el.className);
+        });
+    },
+    toggle: function(els, name) {
+        els = $safeEls(els);
+        each(els, function(el) {
+            if (!exports.has(el, name)) return exports.add(el, name);
+            exports.remove(el, name);
+        });
+    },
+    remove: function(els, name) {
+        els = $safeEls(els);
+        var names = safeName(name);
+        each(els, function(el) {
+            each(names, function(name) {
+                el.classList.remove(name);
+            });
+        });
+    }
+};
+function safeName(name) {
+    return isStr(name) ? name.split(/\s+/) : toArr(name);
+}
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/$css.d.ts

@@ -0,0 +1,11 @@
+import $safeEls = require('./$safeEls');
+import types = require('./types');
+
+declare function $css(element: $safeEls.El, name: string): string;
+declare function $css(element: $safeEls.El, name: string, val: string): void;
+declare function $css(
+    element: $safeEls.El,
+    properties: types.PlainObj<string | number>
+): void;
+
+export = $css;

uni_modules/UniDevTools/node_modules/licia/$css.js

@@ -0,0 +1,51 @@
+var isStr = require('./isStr');
+var isObj = require('./isObj');
+var kebabCase = require('./kebabCase');
+var isUndef = require('./isUndef');
+var contain = require('./contain');
+var isNum = require('./isNum');
+var $safeEls = require('./$safeEls');
+var prefix = require('./prefix');
+var each = require('./each');
+exports = function(nodes, name, val) {
+    nodes = $safeEls(nodes);
+    var isGetter = isUndef(val) && isStr(name);
+    if (isGetter) return getCss(nodes[0], name);
+    var css = name;
+    if (!isObj(css)) {
+        css = {};
+        css[name] = val;
+    }
+    setCss(nodes, css);
+};
+function getCss(node, name) {
+    return (
+        node.style[prefix(name)] ||
+        getComputedStyle(node, '').getPropertyValue(name)
+    );
+}
+function setCss(nodes, css) {
+    each(nodes, function(node) {
+        var cssText = ';';
+        each(css, function(val, key) {
+            key = prefix.dash(key);
+            cssText += key + ':' + addPx(key, val) + ';';
+        });
+        node.style.cssText += cssText;
+    });
+}
+var cssNumProps = [
+    'column-count',
+    'columns',
+    'font-weight',
+    'line-weight',
+    'opacity',
+    'z-index',
+    'zoom'
+];
+function addPx(key, val) {
+    var needPx = isNum(val) && !contain(cssNumProps, kebabCase(key));
+    return needPx ? val + 'px' : val;
+}
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/$data.d.ts

@@ -0,0 +1,11 @@
+import $safeEls = require('./$safeEls');
+import types = require('./types');
+
+declare function $data(element: $safeEls.El, name: string, value: string): void;
+declare function $data(
+    element: $safeEls.El,
+    attributes: types.PlainObj<string>
+): void;
+declare function $data(element: $safeEls.El, name: string): string;
+
+export = $data;

uni_modules/UniDevTools/node_modules/licia/$data.js

@@ -0,0 +1,18 @@
+var $attr = require('./$attr');
+var isStr = require('./isStr');
+var isObj = require('./isObj');
+var each = require('./each');
+var $safeEls = require('./$safeEls');
+exports = function(nodes, name, val) {
+    var dataName = name;
+    if (isStr(name)) dataName = 'data-' + name;
+    if (isObj(name)) {
+        dataName = {};
+        each(name, function(val, key) {
+            dataName['data-' + key] = val;
+        });
+    }
+    return $attr(nodes, dataName, val);
+};
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/$event.d.ts

@@ -0,0 +1,21 @@
+import $safeEls = require('./$safeEls');
+import types = require('./types');
+
+declare const $event: {
+    on(
+        element: $safeEls.El,
+        event: string,
+        selector: string,
+        handler: types.AnyFn
+    ): void;
+    on(element: $safeEls.El, event: string, handler: types.AnyFn): void;
+    off(
+        element: $safeEls.El,
+        event: string,
+        selector: string,
+        handler: types.AnyFn
+    ): void;
+    off(element: $safeEls.El, event: string, handler: types.AnyFn): void;
+};
+
+export = $event;

uni_modules/UniDevTools/node_modules/licia/$event.js

@@ -0,0 +1,22 @@
+var delegate = require('./delegate');
+var isUndef = require('./isUndef');
+var $safeEls = require('./$safeEls');
+var each = require('./each');
+exports = {
+    on: eventFactory('add'),
+    off: eventFactory('remove')
+};
+function eventFactory(type) {
+    return function(nodes, event, selector, handler) {
+        nodes = $safeEls(nodes);
+        if (isUndef(handler)) {
+            handler = selector;
+            selector = undefined;
+        }
+        each(nodes, function(node) {
+            delegate[type](node, event, selector, handler);
+        });
+    };
+}
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/$insert.d.ts

@@ -0,0 +1,13 @@
+import $safeEls = require('./$safeEls');
+
+declare namespace $insert {
+    type IInsert = (element: $safeEls.El, content: string | Element) => void;
+}
+declare const $insert: {
+    before: $insert.IInsert;
+    after: $insert.IInsert;
+    append: $insert.IInsert;
+    prepend: $insert.IInsert;
+};
+
+export = $insert;

uni_modules/UniDevTools/node_modules/licia/$insert.js

@@ -0,0 +1,41 @@
+var each = require('./each');
+var $safeEls = require('./$safeEls');
+var isStr = require('./isStr');
+exports = {
+    before: insertFactory('beforebegin'),
+    after: insertFactory('afterend'),
+    append: insertFactory('beforeend'),
+    prepend: insertFactory('afterbegin')
+};
+function insertFactory(type) {
+    return function(nodes, val) {
+        nodes = $safeEls(nodes);
+        each(nodes, function(node) {
+            if (isStr(val)) {
+                node.insertAdjacentHTML(type, val);
+            } else {
+                var parentNode = node.parentNode;
+                switch (type) {
+                    case 'beforebegin':
+                        if (parentNode) {
+                            parentNode.insertBefore(val, node);
+                        }
+                        break;
+                    case 'afterend':
+                        if (parentNode) {
+                            parentNode.insertBefore(val, node.nextSibling);
+                        }
+                        break;
+                    case 'beforeend':
+                        node.appendChild(val);
+                        break;
+                    case 'afterbegin':
+                        node.prepend(val);
+                        break;
+                }
+            }
+        });
+    };
+}
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/$offset.d.ts

@@ -0,0 +1,13 @@
+import $safeEls = require('./$safeEls');
+
+declare namespace $offset {
+    interface IOffset {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    }
+}
+declare function $offset(element: $safeEls.El): $offset.IOffset;
+
+export = $offset;

uni_modules/UniDevTools/node_modules/licia/$offset.js

@@ -0,0 +1,14 @@
+var $safeEls = require('./$safeEls');
+exports = function(els) {
+    els = $safeEls(els);
+    var el = els[0];
+    var clientRect = el.getBoundingClientRect();
+    return {
+        left: clientRect.left + window.pageXOffset,
+        top: clientRect.top + window.pageYOffset,
+        width: Math.round(clientRect.width),
+        height: Math.round(clientRect.height)
+    };
+};
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/$property.d.ts

@@ -0,0 +1,15 @@
+import $safeEls = require('./$safeEls');
+
+declare namespace $property {
+    interface IProperty {
+        (element: $safeEls.El, value: string): void;
+        (element: $safeEls.El): string;
+    }
+}
+declare const $property: {
+    html: $property.IProperty;
+    val: $property.IProperty;
+    text: $property.IProperty;
+};
+
+export = $property;

uni_modules/UniDevTools/node_modules/licia/$property.js

@@ -0,0 +1,23 @@
+var isUndef = require('./isUndef');
+var each = require('./each');
+var $safeEls = require('./$safeEls');
+exports = {
+    html: propFactory('innerHTML'),
+    text: propFactory('textContent'),
+    val: propFactory('value')
+};
+function propFactory(name) {
+    return function(nodes, val) {
+        nodes = $safeEls(nodes);
+        var node = nodes[0];
+        if (isUndef(val)) {
+            return node ? node[name] : '';
+        }
+        if (!node) return;
+        each(nodes, function(node) {
+            node[name] = val;
+        });
+    };
+}
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/$remove.d.ts

@@ -0,0 +1,5 @@
+import $safeEls = require('./$safeEls');
+
+declare function $remove(element: $safeEls.El);
+
+export = $remove;

uni_modules/UniDevTools/node_modules/licia/$remove.js

@@ -0,0 +1,11 @@
+var each = require('./each');
+var $safeEls = require('./$safeEls');
+exports = function(els) {
+    els = $safeEls(els);
+    each(els, function(el) {
+        var parent = el.parentNode;
+        if (parent) parent.removeChild(el);
+    });
+};
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/$safeEls.d.ts

@@ -0,0 +1,6 @@
+declare namespace $safeEls {
+    type El = Element | Element[] | NodeListOf<Element> | string;
+}
+declare function $safeEls(val: $safeEls.El): Element[];
+
+export = $safeEls;

uni_modules/UniDevTools/node_modules/licia/$safeEls.js

@@ -0,0 +1,8 @@
+var isStr = require('./isStr');
+var toArr = require('./toArr');
+var Select = require('./Select');
+exports = function(val) {
+    return toArr(isStr(val) ? new Select(val) : val);
+};
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/$show.d.ts

@@ -0,0 +1,5 @@
+import $safeEls = require('./$safeEls');
+
+declare function $show(element: $safeEls.El): void;
+
+export = $show;

uni_modules/UniDevTools/node_modules/licia/$show.js

@@ -0,0 +1,28 @@
+var each = require('./each');
+var $safeEls = require('./$safeEls');
+exports = function(els) {
+    els = $safeEls(els);
+    each(els, function(el) {
+        if (isHidden(el)) {
+            el.style.display = getDefDisplay(el.nodeName);
+        }
+    });
+};
+function isHidden(el) {
+    return getComputedStyle(el, '').getPropertyValue('display') == 'none';
+}
+var elDisplay = {};
+function getDefDisplay(elName) {
+    var el, display;
+    if (!elDisplay[elName]) {
+        el = document.createElement(elName);
+        document.documentElement.appendChild(el);
+        display = getComputedStyle(el, '').getPropertyValue('display');
+        el.parentNode.removeChild(el);
+        display == 'none' && (display = 'block');
+        elDisplay[elName] = display;
+    }
+    return elDisplay[elName];
+}
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/Benchmark.d.ts

@@ -0,0 +1,34 @@
+import Promise = require('./Promise');
+import delay = require('./delay');
+import types = require('./types');
+
+declare namespace Benchmark {
+    interface IOptions {
+        minTime?: number;
+        maxTime?: number;
+        minSamples?: number;
+        delay?: number;
+        name?: string;
+    }
+    interface IResult {
+        name: string;
+        mean: number;
+        variance: number;
+        deviation: number;
+        sem: number;
+        moe: number;
+        rme: number;
+        hz: number;
+        sample: number[];
+    }
+}
+declare class Benchmark {
+    constructor(fn: types.AnyFn, options?: Benchmark.IOptions);
+    run(): Promise<Benchmark.IResult>;
+    static all(
+        benches: Array<types.AnyFn | Benchmark>,
+        options?: Benchmark.IOptions
+    ): Promise<Benchmark.IResult[]>;
+}
+
+export = Benchmark;

uni_modules/UniDevTools/node_modules/licia/Benchmark.js

@@ -0,0 +1,244 @@
+var Class = require('./Class');
+var defaults = require('./defaults');
+var Promise = require('./Promise');
+var perfNow = require('./perfNow');
+var delay = require('./delay');
+var average = require('./average');
+var reduce = require('./reduce');
+var each = require('./each');
+var map = require('./map');
+var table = require('./table');
+var toStr = require('./toStr');
+exports = Class(
+    {
+        initialize: function Benchmark(fn) {
+            var options =
+                arguments.length > 1 && arguments[1] !== undefined
+                    ? arguments[1]
+                    : {};
+            defaults(options, defOpts);
+            this._fn = fn;
+            this._isRunning = false;
+            this._options = options;
+        },
+        run: function() {
+            var _this = this;
+            if (this._isRunning) {
+                return this._pendingPromise;
+            }
+            this._reset();
+            this._isRunning = true;
+            var options = this._options;
+            var pendingPromise = new Promise(function(resolve, reject) {
+                var runSample = function() {
+                    var initCount =
+                        arguments.length > 0 && arguments[0] !== undefined
+                            ? arguments[0]
+                            : 1;
+                    delay(function() {
+                        _this
+                            ._runSample(initCount)
+                            .then(function(_ref) {
+                                var period = _ref.period,
+                                    count = _ref.count;
+                                var sample = _this._sample;
+                                sample.push(period);
+                                if (
+                                    perfNow() - _this._timeStamp <
+                                        options.maxTime ||
+                                    sample.length < options.minSamples
+                                ) {
+                                    runSample(count);
+                                } else {
+                                    resolve(_this._calcResult());
+                                }
+                            })
+                            .catch(function(err) {
+                                reject(err);
+                            });
+                    }, options.delay);
+                };
+                runSample();
+            });
+            function complete() {
+                this._isRunning = false;
+                delete this._pendingPromise;
+            }
+            pendingPromise.then(complete).catch(complete);
+            this._pendingPromise = pendingPromise;
+            return pendingPromise;
+        },
+        _reset: function() {
+            this._timeStamp = perfNow();
+            this._sample = [];
+        },
+        _calcResult: function() {
+            var sample = this._sample;
+            var result = {
+                sample: sample,
+                toString: function() {
+                    var hz = this.hz,
+                        rme = this.rme,
+                        name = this.name;
+                    var size = this.sample.length;
+                    return ''
+                        .concat(name, ' x ')
+                        .concat(
+                            formatNumber(hz.toFixed(hz < 100 ? 2 : 0)),
+                            ' ops/sec \xB1'
+                        )
+                        .concat(rme.toFixed(2), '% (')
+                        .concat(size, ' run')
+                        .concat(size === 1 ? '' : 's', ' sampled)');
+                }
+            };
+            var size = sample.length;
+            result.name = this._options.name || this._fn.name || 'anonymous';
+            result.mean = average.apply(null, sample);
+            function varOf(sum, x) {
+                return sum + Math.pow(x - result.mean, 2);
+            }
+            result.variance = reduce(sample, varOf, 0) / (size - 1) || 0;
+            result.deviation = Math.sqrt(result.variance);
+            result.sem = result.deviation / Math.sqrt(size);
+            var critical = tTable[Math.round(size - 1) || 1] || tTable.infinity;
+            result.moe = result.sem * critical;
+            result.rme = (result.moe / result.mean) * 100 || 0;
+            result.hz = 1000 / result.mean;
+            return result;
+        },
+        _runSample: function(count) {
+            var _this2 = this;
+            var options = this._options;
+            var minTime = options.minTime;
+            return new Promise(function(resolve, reject) {
+                var runCycle = function(count) {
+                    delay(function() {
+                        var elapsed = 0;
+                        try {
+                            elapsed = _this2._runCycle(count);
+                        } catch (e) {
+                            return reject(e);
+                        }
+                        var period = elapsed / count;
+                        if (elapsed < minTime) {
+                            if (elapsed === 0) {
+                                count *= 100;
+                            } else {
+                                count += Math.ceil(
+                                    (minTime - elapsed) / period
+                                );
+                            }
+                            runCycle(count);
+                        } else {
+                            resolve({
+                                count: count,
+                                period: period
+                            });
+                        }
+                    }, options.delay);
+                };
+                runCycle(count);
+            });
+        },
+        _runCycle: function(count) {
+            var fn = this._fn;
+            var now = perfNow();
+            while (count--) {
+                fn();
+            }
+            return perfNow() - now;
+        }
+    },
+    {
+        all: function(benches, options) {
+            var promises = [];
+            each(benches, function(bench) {
+                if (!(bench instanceof exports)) {
+                    bench = new exports(bench, options);
+                }
+                promises.push(bench.run());
+            });
+            return Promise.all(promises).then(function(results) {
+                results.toString = function() {
+                    var data = map(results, function(_ref2, idx) {
+                        var name = _ref2.name,
+                            sample = _ref2.sample,
+                            hz = _ref2.hz,
+                            rme = _ref2.rme;
+                        var columns = [];
+                        var size = sample.length;
+                        columns.push(
+                            toStr(idx + 1),
+                            name || 'anonymous',
+                            formatNumber(hz.toFixed(hz < 100 ? 2 : 0)),
+                            '\xB1'.concat(rme.toFixed(2), '%'),
+                            ''
+                                .concat(size, ' run')
+                                .concat(size === 1 ? '' : 's')
+                        );
+                        return columns;
+                    });
+                    data.unshift([
+                        'index',
+                        'name',
+                        'ops/sec',
+                        'rme',
+                        'sampled'
+                    ]);
+                    return table(data);
+                };
+                return results;
+            });
+        }
+    }
+);
+var defOpts = {
+    minTime: 50,
+    maxTime: 5000,
+    minSamples: 5,
+    delay: 5,
+    name: ''
+};
+var tTable = {
+    '1': 12.706,
+    '2': 4.303,
+    '3': 3.182,
+    '4': 2.776,
+    '5': 2.571,
+    '6': 2.447,
+    '7': 2.365,
+    '8': 2.306,
+    '9': 2.262,
+    '10': 2.228,
+    '11': 2.201,
+    '12': 2.179,
+    '13': 2.16,
+    '14': 2.145,
+    '15': 2.131,
+    '16': 2.12,
+    '17': 2.11,
+    '18': 2.101,
+    '19': 2.093,
+    '20': 2.086,
+    '21': 2.08,
+    '22': 2.074,
+    '23': 2.069,
+    '24': 2.064,
+    '25': 2.06,
+    '26': 2.056,
+    '27': 2.052,
+    '28': 2.048,
+    '29': 2.045,
+    '30': 2.042,
+    infinity: 1.96
+};
+function formatNumber(number) {
+    number = String(number).split('.');
+    return (
+        number[0].replace(/(?=(?:\d{3})+$)(?!\b)/g, ',') +
+        (number[1] ? '.' + number[1] : '')
+    );
+}
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/Blob.d.ts

@@ -0,0 +1 @@
+export = Blob;

uni_modules/UniDevTools/node_modules/licia/Blob.js

@@ -0,0 +1,21 @@
+var root = require('./root');
+var each = require('./each');
+exports =
+    root.Blob ||
+    function Blob(parts, options) {
+        options = options || {};
+        var blobBuilder = new BlobBuilder();
+        each(parts, function(part) {
+            blobBuilder.append(part);
+        });
+        return options.type
+            ? blobBuilder.getBlob(options.type)
+            : blobBuilder.getBlob();
+    };
+var BlobBuilder =
+    root.BlobBuilder ||
+    root.WebKitBlobBuilder ||
+    root.MSBlobBuilder ||
+    root.MozBlobBuilder;
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/BloomFilter.d.ts

@@ -0,0 +1,7 @@
+declare class BloomFilter {
+    constructor(size?: number, k?: number);
+    add(val: string): void;
+    test(val: string): boolean;
+}
+
+export = BloomFilter;

uni_modules/UniDevTools/node_modules/licia/BloomFilter.js

@@ -0,0 +1,46 @@
+var Class = require('./Class');
+var fill = require('./fill');
+var fnv1a = require('./fnv1a');
+var strHash = require('./strHash');
+var each = require('./each');
+var some = require('./some');
+exports = Class({
+    initialize: function() {
+        var size =
+            arguments.length > 0 && arguments[0] !== undefined
+                ? arguments[0]
+                : 1024;
+        var k =
+            arguments.length > 1 && arguments[1] !== undefined
+                ? arguments[1]
+                : 3;
+        this._buckets = fill(new Array(size), 0);
+        this._k = k;
+        this._size = size;
+    },
+    add: function(val) {
+        var _this = this;
+        each(this._locations(val), function(location) {
+            return (_this._buckets[location] = 1);
+        });
+    },
+    test: function(val) {
+        var _this2 = this;
+        return !some(this._locations(val), function(location) {
+            return _this2._buckets[location] === 0;
+        });
+    },
+    _locations: function(val) {
+        var ret = [];
+        var size = this._size;
+        var a = fnv1a(val);
+        var b = strHash(val);
+
+        for (var i = 0; i < this._k; i++) {
+            ret[i] = (a + b * i) % size;
+        }
+        return ret;
+    }
+});
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/Caseless.d.ts

@@ -0,0 +1,10 @@
+declare class Caseless {
+    constructor(obj: any);
+    getKey(key: string): string | void;
+    set(key: string, val: any): void;
+    get(key: string): any;
+    remove(key: string): void;
+    has(key: string): boolean;
+}
+
+export = Caseless;

uni_modules/UniDevTools/node_modules/licia/Caseless.js

@@ -0,0 +1,35 @@
+var Class = require('./Class');
+var lowerCase = require('./lowerCase');
+var keys = require('./keys');
+exports = Class({
+    initialize: function(obj) {
+        this._target = obj;
+    },
+    set: function(key, val) {
+        var name = this.getKey(key);
+        if (name) key = name;
+        this._target[key] = val;
+    },
+    get: function(key) {
+        key = this.getKey(key);
+        if (key) {
+            return this._target[key];
+        }
+    },
+    getKey: function(key) {
+        var name = lowerCase(key);
+        var _keys = keys(this._target);
+        for (var i = 0, len = _keys.length; i < len; i++) {
+            var _key = _keys[i];
+            if (lowerCase(_key) === name) return _key;
+        }
+    },
+    remove: function(key) {
+        delete this._target[this.getKey(key)];
+    },
+    has: function(key) {
+        return !!this.getKey(key);
+    }
+});
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/Class.d.ts

@@ -0,0 +1,20 @@
+import extend = require('./extend');
+import inherits = require('./inherits');
+import types = require('./types');
+
+declare namespace Class {
+    class Base {
+        toString(): string;
+    }
+    class IConstructor extends Base {
+        constructor(...args: any[]);
+        static extend(methods: any, statics: any): IConstructor;
+        static inherits(Class: types.AnyFn): void;
+        static methods(methods: any): IConstructor;
+        static statics(statics: any): IConstructor;
+        [method: string]: any;
+    }
+}
+declare function Class(methods: any, statics?: any): Class.IConstructor;
+
+export = Class;

uni_modules/UniDevTools/node_modules/licia/Class.js

@@ -0,0 +1,64 @@
+var extend = require('./extend');
+var toArr = require('./toArr');
+var inherits = require('./inherits');
+var safeGet = require('./safeGet');
+var isMiniProgram = require('./isMiniProgram');
+exports = function(methods, statics) {
+    return Base.extend(methods, statics);
+};
+function makeClass(parent, methods, statics) {
+    statics = statics || {};
+    var className =
+        methods.className || safeGet(methods, 'initialize.name') || '';
+    delete methods.className;
+    var ctor = function() {
+        var args = toArr(arguments);
+        return this.initialize
+            ? this.initialize.apply(this, args) || this
+            : this;
+    };
+    if (!isMiniProgram) {
+        try {
+            ctor = new Function(
+                'toArr',
+                'return function ' +
+                    className +
+                    '()' +
+                    '{' +
+                    'var args = toArr(arguments);' +
+                    'return this.initialize ? this.initialize.apply(this, args) || this : this;' +
+                    '};'
+            )(toArr);
+        } catch (e) {}
+    }
+    inherits(ctor, parent);
+    ctor.prototype.constructor = ctor;
+    ctor.extend = function(methods, statics) {
+        return makeClass(ctor, methods, statics);
+    };
+    ctor.inherits = function(Class) {
+        inherits(ctor, Class);
+    };
+    ctor.methods = function(methods) {
+        extend(ctor.prototype, methods);
+        return ctor;
+    };
+    ctor.statics = function(statics) {
+        extend(ctor, statics);
+        return ctor;
+    };
+    ctor.methods(methods).statics(statics);
+    return ctor;
+}
+var Base = (exports.Base = makeClass(Object, {
+    className: 'Base',
+    callSuper: function(parent, name, args) {
+        var superMethod = parent.prototype[name];
+        return superMethod.apply(this, args);
+    },
+    toString: function() {
+        return this.constructor.name;
+    }
+}));
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/Color.d.ts

@@ -0,0 +1,15 @@
+declare namespace Color {
+    interface IColor {
+        val: number[];
+        model: string;
+    }
+}
+declare class Color {
+    constructor(color: string | Color.IColor);
+    toRgb(): string;
+    toHex(): string;
+    toHsl(): string;
+    static parse(colorStr: string): Color.IColor;
+}
+
+export = Color;

uni_modules/UniDevTools/node_modules/licia/Color.js

@@ -0,0 +1,95 @@
+var Class = require('./Class');
+var isStr = require('./isStr');
+var clamp = require('./clamp');
+var rgbToHsl = require('./rgbToHsl');
+var hslToRgb = require('./hslToRgb');
+var hex = require('./hex');
+exports = Class(
+    {
+        initialize: function Color(color) {
+            if (isStr(color)) color = exports.parse(color);
+            this.model = color.model;
+            this.val = color.val;
+        },
+        toRgb: function() {
+            var val = this.val;
+            if (this.model === 'hsl') val = hslToRgb(val);
+            var prefix = 'rgba';
+            if (val[3] === 1) {
+                prefix = 'rgb';
+                val = val.slice(0, 3);
+            }
+            return prefix + '(' + val.join(', ') + ')';
+        },
+        toHex: function() {
+            var val = this.val;
+            if (this.model === 'hsl') val = hslToRgb(val);
+            var ret = hex.encode(val.slice(0, 3));
+            if (ret[0] === ret[1] && ret[2] === ret[3] && ret[4] === ret[5]) {
+                ret = ret[0] + ret[2] + ret[5];
+            }
+            return '#' + ret;
+        },
+        toHsl: function() {
+            var val = this.val;
+            if (this.model === 'rgb') val = rgbToHsl(val);
+            var prefix = 'hsla';
+            if (val[3] === 1) {
+                prefix = 'hsl';
+                val = val.slice(0, 3);
+            }
+            val[1] = val[1] + '%';
+            val[2] = val[2] + '%';
+            return prefix + '(' + val.join(', ') + ')';
+        }
+    },
+    {
+        parse: function(colorStr) {
+            var i, match;
+            var val = [0, 0, 0, 1],
+                model = 'rgb';
+
+            if ((match = colorStr.match(regHexAbbr))) {
+                match = match[1];
+                for (i = 0; i < 3; i++) {
+                    val[i] = parseInt(match[i] + match[i], 16);
+                }
+            } else if ((match = colorStr.match(regHex))) {
+                match = match[1];
+                for (i = 0; i < 3; i++) {
+                    var i2 = i * 2;
+                    val[i] = parseInt(match.slice(i2, i2 + 2), 16);
+                }
+            } else if ((match = colorStr.match(regRgba))) {
+                for (i = 0; i < 3; i++) {
+                    val[i] = parseInt(match[i + 1], 0);
+                }
+                if (match[4]) val[3] = parseFloat(match[4]);
+            } else if ((match = colorStr.match(regRgbaPer))) {
+                for (i = 0; i < 3; i++) {
+                    val[i] = Math.round(parseFloat(match[i + 1]) * 2.55);
+                }
+                if (match[4]) val[3] = parseFloat(match[4]);
+            } else if ((match = colorStr.match(regHsla))) {
+                model = 'hsl';
+                val = [
+                    ((parseFloat(match[1]) % 360) + 360) % 360,
+                    clamp(parseFloat(match[2]), 0, 100),
+                    clamp(parseFloat(match[3]), 0, 100),
+                    clamp(parseFloat(match[4]), 0, 1)
+                ];
+            }
+            return {
+                val: val,
+                model: model
+            };
+        }
+    }
+);
+var regHexAbbr = /^#([a-fA-F0-9]{3})$/;
+var regHex = /^#([a-fA-F0-9]{6})$/;
+var regRgba = /^rgba?\(\s*([+-]?\d+)\s*,\s*([+-]?\d+)\s*,\s*([+-]?\d+)\s*(?:,\s*([+-]?[\d.]+)\s*)?\)$/;
+var regRgbaPer = /^rgba?\(\s*([+-]?[\d.]+)%\s*,\s*([+-]?[\d.]+)%\s*,\s*([+-]?[\d.]+)%\s*(?:,\s*([+-]?[\d.]+)\s*)?\)$/;
+var regHsla = /^hsla?\(\s*([+-]?\d*[.]?\d+)(?:deg)?\s*,\s*([+-]?[\d.]+)%\s*,\s*([+-]?[\d.]+)%\s*(?:,\s*([+-]?[\d.]+)\s*)?\)$/;
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/Delegator.d.ts

@@ -0,0 +1,9 @@
+declare class Delegator {
+    constructor(host: object, target: object | string);
+    method(name: string, target?: string): Delegator;
+    getter(name: string, target?: string): Delegator;
+    setter(name: string, target?: string): Delegator;
+    access(name: string, target?: string): Delegator;
+}
+
+export = Delegator;

uni_modules/UniDevTools/node_modules/licia/Delegator.js

@@ -0,0 +1,48 @@
+var Class = require('./Class');
+var safeGet = require('./safeGet');
+var defineProp = require('./defineProp');
+var isStr = require('./isStr');
+exports = Class({
+    initialize: function Delegator(host, target) {
+        this._host = host;
+        if (isStr(target)) {
+            target = safeGet(host, target);
+        }
+        this._target = target;
+    },
+    method: function(name, targetName) {
+        var target = this._target;
+        var fn = target[targetName || name];
+        this._host[name] = function() {
+            return fn.apply(target, arguments);
+        };
+        return this;
+    },
+    getter: function(name, targetName) {
+        var target = this._target;
+        targetName = targetName || name;
+        defineProp(this._host, name, {
+            get: function() {
+                return target[targetName];
+            },
+            configurable: true
+        });
+        return this;
+    },
+    setter: function(name, targetName) {
+        var target = this._target;
+        targetName = targetName || name;
+        defineProp(this._host, name, {
+            set: function(val) {
+                return (target[targetName] = val);
+            },
+            configurable: true
+        });
+        return this;
+    },
+    access: function(name, targetName) {
+        return this.getter(name, targetName).setter(name, targetName);
+    }
+});
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/Dispatcher.d.ts

@@ -0,0 +1,11 @@
+import types = require('./types');
+
+declare class Dispatcher {
+    dispatch(payload: any);
+    register(cb: types.AnyFn): void;
+    waitFor(ids: string[]): void;
+    unregister(id: string): void;
+    isDispatching(): boolean;
+}
+
+export = Dispatcher;

uni_modules/UniDevTools/node_modules/licia/Dispatcher.js

@@ -0,0 +1,55 @@
+var Class = require('./Class');
+var uniqId = require('./uniqId');
+exports = Class({
+    initialize: function Dispatcher() {
+        this._callbacks = {};
+        this._isDispatching = false;
+        this._isHandled = {};
+        this._isPending = {};
+    },
+    dispatch: function(payload) {
+        this._startDispatching(payload);
+        for (var id in this._callbacks) {
+            if (this._isPending[id]) continue;
+            this._invokeCb(id);
+        }
+        this._stopDispatching();
+    },
+    register: function(cb) {
+        var id = uniqId('ID_');
+        this._callbacks[id] = cb;
+        return id;
+    },
+    waitFor: function(ids) {
+        for (var i = 0, len = ids.length; i < len; i++) {
+            var id = ids[i];
+            if (this._isPending[id]) continue;
+            this._invokeCb(id);
+        }
+    },
+    unregister: function(id) {
+        delete this._callbacks[id];
+    },
+    isDispatching: function() {
+        return this._isDispatching;
+    },
+    _startDispatching: function(payload) {
+        for (var id in this._callbacks) {
+            this._isPending[id] = false;
+            this._isHandled[id] = false;
+        }
+        this._pendingPayload = payload;
+        this._isDispatching = true;
+    },
+    _stopDispatching: function() {
+        delete this._pendingPayload;
+        this._isDispatching = false;
+    },
+    _invokeCb: function(id) {
+        this._isPending[id] = true;
+        this._callbacks[id](this._pendingPayload);
+        this._isHandled[id] = true;
+    }
+});
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/Emitter.d.ts

@@ -0,0 +1,13 @@
+import once = require('./once');
+import types = require('./types');
+
+declare class Emitter {
+    on(event: string, listener: types.AnyFn): Emitter;
+    off(event: string, listener: types.AnyFn): Emitter;
+    once(event: string, listener: types.AnyFn): Emitter;
+    emit(event: string, ...args: any[]): Emitter;
+    removeAllListeners(event?: string): Emitter;
+    static mixin(obj: any): any;
+}
+
+export = Emitter;

uni_modules/UniDevTools/node_modules/licia/Emitter.js

@@ -0,0 +1,65 @@
+var Class = require('./Class');
+var has = require('./has');
+var each = require('./each');
+var slice = require('./slice');
+var once = require('./once');
+var clone = require('./clone');
+exports = Class(
+    {
+        initialize: function Emitter() {
+            this._events = this._events || {};
+        },
+        on: function(event, listener) {
+            this._events[event] = this._events[event] || [];
+            this._events[event].push(listener);
+            return this;
+        },
+        off: function(event, listener) {
+            var events = this._events;
+            if (!has(events, event)) return;
+            var idx = events[event].indexOf(listener);
+            if (idx > -1) {
+                events[event].splice(idx, 1);
+            }
+            return this;
+        },
+        once: function(event, listener) {
+            this.on(event, once(listener));
+            return this;
+        },
+        emit: function(event) {
+            var _this = this;
+            if (!has(this._events, event)) return;
+            var args = slice(arguments, 1);
+            var events = clone(this._events[event]);
+            each(
+                events,
+                function(val) {
+                    return val.apply(_this, args);
+                },
+                this
+            );
+            return this;
+        },
+        removeAllListeners: function(event) {
+            if (!event) {
+                this._events = {};
+            } else {
+                delete this._events[event];
+            }
+            return this;
+        }
+    },
+    {
+        mixin: function(obj) {
+            each(['on', 'off', 'once', 'emit', 'removeAllListeners'], function(
+                val
+            ) {
+                obj[val] = exports.prototype[val];
+            });
+            obj._events = obj._events || {};
+        }
+    }
+);
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/Enum.d.ts

@@ -0,0 +1,7 @@
+declare class Enum {
+    size: number;
+    constructor(map: string[] | { [member: string]: any });
+    [key: string]: any;
+}
+
+export = Enum;

uni_modules/UniDevTools/node_modules/licia/Enum.js

@@ -0,0 +1,31 @@
+var Class = require('./Class');
+var freeze = require('./freeze');
+var isArr = require('./isArr');
+var each = require('./each');
+var keys = require('./keys');
+exports = Class({
+    initialize: function Enum(map) {
+        if (isArr(map)) {
+            this.size = map.length;
+            each(
+                map,
+                function(member, val) {
+                    this[member] = val;
+                },
+                this
+            );
+        } else {
+            this.size = keys(map).length;
+            each(
+                map,
+                function(val, member) {
+                    this[member] = val;
+                },
+                this
+            );
+        }
+        freeze(this);
+    }
+});
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/FileBlobStore.d.ts

@@ -0,0 +1,19 @@
+import types = require('./types');
+import each = require('./each');
+import Emitter = require('./Emitter');
+import keys = require('./keys');
+
+declare class FileBlobStore extends Emitter {
+    constructor(path: string, data?: types.PlainObj<Buffer>);
+    set(key: string, buf: Buffer): void;
+    set(values: types.PlainObj<Buffer>): void;
+    get(key: string): Buffer | void;
+    get(keys: string[]): types.PlainObj<Buffer>;
+    remove(key: string): void;
+    remove(keys: string[]): void;
+    clear(): void;
+    each(fn: (val: Buffer, key: string) => void): void;
+    save(): void;
+}
+
+export = FileBlobStore;

uni_modules/UniDevTools/node_modules/licia/FileBlobStore.js

@@ -0,0 +1,138 @@
+const isStr = require('./isStr');
+const isObj = require('./isObj');
+const each = require('./each');
+const Emitter = require('./Emitter');
+const toArr = require('./toArr');
+const unique = require('./unique');
+const concat = require('./concat');
+const keys = require('./keys');
+
+const fs = require('fs');
+
+exports = Emitter.extend({
+    initialize: function FileBlobStore(path, data) {
+        this.callSuper(Emitter, 'initialize', arguments);
+        this._path = path;
+        this._mapPath = path + '.MAP';
+        this._lockPath = path + '.LOCK';
+        this._data = data || {};
+
+        let storedBlob = Buffer.alloc(0);
+        let storedBlobMap = {};
+        if (fs.existsSync(path) && fs.existsSync(this._mapPath)) {
+            try {
+                storedBlob = fs.readFileSync(path);
+                storedBlobMap = JSON.parse(fs.readFileSync(this._mapPath));
+            } catch (e) {
+                storedBlobMap = {};
+                storedBlob = Buffer.alloc(0);
+            }
+        }
+        this._storedBlob = storedBlob;
+        this._storedBlobMap = storedBlobMap;
+    },
+    set(key, buf) {
+        let data;
+
+        if (isStr(key)) {
+            data = {};
+            data[key] = buf;
+        } else if (isObj(key)) {
+            data = key;
+        }
+
+        each(data, (buf, key) => {
+            const oldBuf = this.get(key);
+            this._data[key] = buf;
+            this.emit('change', key, buf, oldBuf);
+        });
+    },
+    get(key) {
+        if (isStr(key)) {
+            return this._get(key);
+        }
+
+        const ret = {};
+        each(key, val => {
+            ret[val] = this._get(val);
+        });
+
+        return ret;
+    },
+    remove(key) {
+        key = toArr(key);
+        const data = this._data;
+        const storedBlobMap = this._storedBlobMap;
+
+        each(key, val => {
+            delete data[val];
+            delete storedBlobMap[val];
+        });
+    },
+    clear() {
+        this._data = {};
+        this._storedBlob = Buffer.alloc(0);
+        this._storedBlobMap = {};
+    },
+    each(fn) {
+        const allKeys = this._getKeys();
+
+        each(allKeys, key => {
+            fn(this._get(key), key);
+        });
+    },
+    save() {
+        const dump = this._getDump();
+        const blobToStore = Buffer.concat(dump[0]);
+        const mapToStore = JSON.stringify(dump[1]);
+
+        let lock = false;
+        try {
+            fs.writeFileSync(this._lockPath, 'LOCK', { flag: 'wx' });
+            lock = true;
+
+            fs.writeFileSync(this._path, blobToStore);
+            fs.writeFileSync(this._mapPath, mapToStore);
+        } catch (error) {
+            if (error.code !== 'EEXIST') {
+                throw error;
+            }
+        } finally {
+            if (lock) {
+                fs.unlinkSync(this._lockPath);
+            }
+        }
+    },
+    _get(key) {
+        return this._data[key] || this._getFromStorage(key);
+    },
+    _getFromStorage(key) {
+        if (!this._storedBlobMap[key]) {
+            return;
+        }
+
+        const [start, end] = this._storedBlobMap[key];
+        return this._storedBlob.slice(start, end);
+    },
+    _getDump() {
+        const buffers = [];
+        const blobMap = {};
+        let curBufStart = 0;
+
+        function dump(buf, key) {
+            buffers.push(buf);
+            const len = buf.length;
+            blobMap[key] = [curBufStart, curBufStart + len];
+            curBufStart += len;
+        }
+
+        this.each(dump);
+
+        return [buffers, blobMap];
+    },
+    _getKeys() {
+        return unique(concat(keys(this._data), keys(this._storedBlobMap)));
+    }
+});
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/FileStore.d.ts

@@ -0,0 +1,7 @@
+import Store = require('./Store');
+
+declare class FileStore extends Store {
+    constructor(path: string, data?: any);
+}
+
+export = FileStore;

uni_modules/UniDevTools/node_modules/licia/FileStore.js

@@ -0,0 +1,41 @@
+const Store = require('./Store');
+const isEmpty = require('./isEmpty');
+const debounce = require('./debounce');
+const stringify = require('./stringify');
+const isObj = require('./isObj');
+const defaults = require('./defaults');
+const noop = require('./noop');
+
+const fs = require('fs');
+
+exports = Store.extend({
+    initialize: function FileStore(path, data) {
+        this._path = path;
+        data = data || {};
+
+        let fileData;
+        if (fs.existsSync(path)) {
+            try {
+                fileData = JSON.parse(fs.readFileSync(path, 'utf8'));
+            } catch (e) {
+                fileData = {};
+            }
+        }
+        if (!isObj(fileData)) {
+            fileData = {};
+        }
+        data = defaults(fileData, data);
+
+        this.save = debounce(data => {
+            if (isEmpty(data)) {
+                fs.unlink(this._path, noop);
+                return;
+            }
+            fs.writeFile(this._path, stringify(data), 'utf8', noop);
+        }, 300);
+
+        this.callSuper(Store, 'initialize', [data]);
+    }
+});
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/HashTable.d.ts

@@ -0,0 +1,11 @@
+import has = require('./has');
+
+declare class HashTable {
+    constructor(size?: number);
+    set(key: string, val: any): void;
+    get(key: string): any;
+    has(key: string): boolean;
+    delete(key: string): void;
+}
+
+export = HashTable;

uni_modules/UniDevTools/node_modules/licia/HashTable.js

@@ -0,0 +1,61 @@
+var Class = require('./Class');
+var LinkedList = require('./LinkedList');
+var map = require('./map');
+var strHash = require('./strHash');
+var has = require('./has');
+exports = Class({
+    initialize: function HashTable() {
+        var size =
+            arguments.length > 0 && arguments[0] !== undefined
+                ? arguments[0]
+                : 32;
+        this._buckets = map(Array(size), function() {
+            return new LinkedList();
+        });
+        this._keys = {};
+    },
+    set: function(key, val) {
+        var keyHash = this._hash(key);
+        this._keys[key] = keyHash;
+        var linkedList = this._buckets[keyHash];
+        var node = linkedList.find(function(val) {
+            return val.key === key;
+        });
+        if (!node) {
+            linkedList.push({
+                key: key,
+                value: val
+            });
+        } else {
+            node.value.value = val;
+        }
+    },
+    get: function(key) {
+        var linkedList = this._buckets[this._hash(key)];
+        var node = linkedList.find(function(val) {
+            return val.key === key;
+        });
+        if (node) {
+            return node.value.value;
+        }
+    },
+    has: function(key) {
+        return has(this._keys, key);
+    },
+    delete: function(key) {
+        var keyHash = this._hash(key);
+        delete this._keys[key];
+        var linkedList = this._buckets[keyHash];
+        var node = linkedList.find(function(val) {
+            return val.key === key;
+        });
+        if (node) {
+            linkedList.rmNode(node);
+        }
+    },
+    _hash: function(key) {
+        return strHash(key) % this._buckets.length;
+    }
+});
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/Heap.d.ts

@@ -0,0 +1,12 @@
+import types = require('./types');
+
+declare class Heap {
+    size: number;
+    constructor(cmp?: types.AnyFn);
+    clear(): void;
+    add(item: any): number;
+    poll(): any;
+    peek(): any;
+}
+
+export = Heap;

uni_modules/UniDevTools/node_modules/licia/Heap.js

@@ -0,0 +1,79 @@
+var Class = require('./Class');
+var swap = require('./swap');
+var isSorted = require('./isSorted');
+exports = Class({
+    initialize: function Heap() {
+        var cmp =
+            arguments.length > 0 && arguments[0] !== undefined
+                ? arguments[0]
+                : isSorted.defComparator;
+        this._cmp = cmp;
+        this.clear();
+    },
+    clear: function() {
+        this._data = [];
+        this.size = 0;
+    },
+    add: function(item) {
+        this._data.push(item);
+        this.size++;
+        this._heapifyUp(this.size - 1);
+        return this.size;
+    },
+    poll: function() {
+        var data = this._data;
+        if (this.size > 0) {
+            var item = data[0];
+            data[0] = data[this.size - 1];
+            this.size--;
+            this._heapifyDown(0);
+            return item;
+        }
+    },
+    peek: function() {
+        if (this.size > 0) {
+            return this._data[0];
+        }
+    },
+    _heapifyUp: function(idx) {
+        var data = this._data;
+        var parent = parentIdx(idx);
+        while (idx > 0 && this._cmp(data[parent], data[idx]) > 0) {
+            swap(data, parent, idx);
+            idx = parent;
+            parent = parentIdx(idx);
+        }
+    },
+    _heapifyDown: function(idx) {
+        var size = this.size;
+        var cmp = this._cmp;
+        var data = this._data;
+        while (leftChildIdx(idx) < size) {
+            var smallerIdx = leftChildIdx(idx);
+            var rightChild = rightChildIdx(idx);
+            if (
+                rightChild < size &&
+                cmp(data[rightChildIdx], data[smallerIdx]) < 0
+            ) {
+                smallerIdx = rightChild;
+            }
+            if (cmp(data[idx], data[smallerIdx]) < 0) {
+                break;
+            } else {
+                swap(data, idx, smallerIdx);
+            }
+            idx = smallerIdx;
+        }
+    }
+});
+function parentIdx(idx) {
+    return Math.floor((idx - 1) / 2);
+}
+function leftChildIdx(idx) {
+    return 2 * idx + 1;
+}
+function rightChildIdx(idx) {
+    return 2 * idx + 2;
+}
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/HeapSnapshot.d.ts

@@ -0,0 +1,9 @@
+import LinkedList = require('./LinkedList');
+
+declare class HeapSnapshot {
+    nodes: LinkedList;
+    edges: LinkedList;
+    constructor(profile: any);
+}
+
+export = HeapSnapshot;

uni_modules/UniDevTools/node_modules/licia/HeapSnapshot.js

@@ -0,0 +1,111 @@
+var Class = require('./Class');
+var toBool = require('./toBool');
+var camelCase = require('./camelCase');
+var LinkedList = require('./LinkedList');
+var isStr = require('./isStr');
+var each = require('./each');
+var map = require('./map');
+exports = Class({
+    initialize: function HeapSnapshot(profile) {
+        if (isStr(profile)) {
+            profile = JSON.parse(profile);
+        }
+        this.nodes = new LinkedList();
+        this.edges = new LinkedList();
+        var snapshot = profile.snapshot;
+        var meta = snapshot.meta;
+        this.nodeFields = map(meta.node_fields, camelCase);
+        this.nodeTypes = meta.node_types[this.nodeFields.indexOf('type')];
+        this.edgeFields = map(meta.edge_fields, camelCase);
+        this.edgeTypes = meta.edge_types[this.edgeFields.indexOf('type')];
+        this._init(profile);
+    },
+    _init: function(profile) {
+        var _this = this;
+        var nodes = profile.nodes,
+            edges = profile.edges,
+            strings = profile.strings;
+        var nodeFields = this.nodeFields,
+            edgeFields = this.edgeFields;
+        var curEdgeIdx = 0;
+        var nodeFieldCount = nodeFields.length;
+        var edgeFieldCount = edgeFields.length;
+        var nodeMap = {};
+        for (var i = 0, len = nodes.length; i < len; i += nodeFieldCount) {
+            var node = new Node(this);
+            node.init(nodes.slice(i, i + nodeFieldCount), strings);
+            this.nodes.push(node);
+            nodeMap[i] = node;
+        }
+        this.nodes.forEach(function(node) {
+            var edgeCount = node.edgeCount;
+            delete node.edgeCount;
+            var maxEdgeIdx = curEdgeIdx + edgeCount * edgeFieldCount;
+            for (var _i = curEdgeIdx; _i < maxEdgeIdx; _i += edgeFieldCount) {
+                var edge = new Edge(_this, node);
+                edge.init(
+                    edges.slice(_i, _i + edgeFieldCount),
+                    strings,
+                    nodeMap
+                );
+                _this.edges.push(edge);
+            }
+            curEdgeIdx = maxEdgeIdx;
+        });
+    }
+});
+var Node = Class({
+    initialize: function Node(heapSnapshot) {
+        this._heapSnapshot = heapSnapshot;
+    },
+    init: function(fields, strings) {
+        var _this2 = this;
+        var heapSnapshot = this._heapSnapshot;
+        var nodeFields = heapSnapshot.nodeFields,
+            nodeTypes = heapSnapshot.nodeTypes;
+        each(nodeFields, function(field, idx) {
+            var val = fields[idx];
+            switch (field) {
+                case 'name':
+                    val = strings[val];
+                    break;
+                case 'detachedness':
+                    val = toBool(val);
+                    break;
+                case 'type':
+                    val = nodeTypes[val];
+                    break;
+            }
+            _this2[field] = val;
+        });
+    }
+});
+var Edge = Class({
+    initialize: function Edge(heapSnapshot, fromNode) {
+        this._heapSnapshot = heapSnapshot;
+        this.fromNode = fromNode;
+    },
+    init: function(fields, strings, nodeMap) {
+        var _this3 = this;
+        var heapSnapshot = this._heapSnapshot;
+        var edgeFields = heapSnapshot.edgeFields,
+            edgeTypes = heapSnapshot.edgeTypes;
+        each(edgeFields, function(field, idx) {
+            var val = fields[idx];
+            switch (field) {
+                case 'nameOrIndex':
+                    val = strings[val];
+                    break;
+                case 'type':
+                    val = edgeTypes[val];
+                    break;
+                case 'toNode':
+                    val = nodeMap[val];
+                    break;
+            }
+            _this3[field] = val;
+        });
+    }
+});
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/I18n.d.ts

@@ -0,0 +1,10 @@
+import types = require('./types');
+
+declare class I18n {
+    constructor(locale: string, langs: types.PlainObj<any>);
+    set(locale: string, lang: types.PlainObj<any>): void;
+    t(path: string | string[], data?: types.PlainObj<any>): string;
+    locale(locale: string): void;
+}
+
+export = I18n;

uni_modules/UniDevTools/node_modules/licia/I18n.js

@@ -0,0 +1,38 @@
+var Class = require('./Class');
+var safeGet = require('./safeGet');
+var extend = require('./extend');
+var strTpl = require('./strTpl');
+var isStr = require('./isStr');
+var isFn = require('./isFn');
+exports = Class({
+    initialize: function I18n(locale, langs) {
+        this._locale = locale;
+        this._langs = langs;
+    },
+    set: function(locale, lang) {
+        if (this._langs[locale]) {
+            extend(this._langs[locale], lang);
+        } else {
+            this._langs[locale] = lang;
+        }
+    },
+    t: function(path, data) {
+        var val = '';
+        var lang = this._langs[this._locale];
+        if (!lang) return '';
+        val = safeGet(lang, path);
+        if (data) {
+            if (isStr(val)) {
+                val = strTpl(val, data);
+            } else if (isFn(val)) {
+                val = val(data);
+            }
+        }
+        return val || '';
+    },
+    locale: function(locale) {
+        this._locale = locale;
+    }
+});
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/JsonTransformer.d.ts

@@ -0,0 +1,23 @@
+import map = require('./map');
+import filter = require('./filter');
+import types = require('./types');
+
+declare class JsonTransformer {
+    constructor(data: any);
+    set(key: string, val: any): JsonTransformer;
+    get(key?: string): any;
+    map(from: string, to: string, fn: types.AnyFn): JsonTransformer;
+    map(from: string, fn: types.AnyFn): JsonTransformer;
+    filter(from: string, to: string, fn: types.AnyFn): JsonTransformer;
+    filter(from: string, fn: types.AnyFn): JsonTransformer;
+    remove(keys: string | string[]): JsonTransformer;
+    compute(
+        from: string | string[],
+        to: string,
+        fn: types.AnyFn
+    ): JsonTransformer;
+    compute(from: string, fn: types.AnyFn): JsonTransformer;
+    toString(): string;
+}
+
+export = JsonTransformer;

uni_modules/UniDevTools/node_modules/licia/JsonTransformer.js

@@ -0,0 +1,68 @@
+var Class = require('./Class');
+var safeSet = require('./safeSet');
+var safeGet = require('./safeGet');
+var map = require('./map');
+var filter = require('./filter');
+var isFn = require('./isFn');
+var safeDel = require('./safeDel');
+var toArr = require('./toArr');
+var each = require('./each');
+exports = Class({
+    className: 'JsonTransformer',
+    initialize: function(data) {
+        this._data = data || {};
+    },
+    set: function(key, val) {
+        if (arguments.length === 1) {
+            this._data = key;
+            return this;
+        }
+        safeSet(this._data, key, val);
+        return this;
+    },
+    get: function(key) {
+        if (key == null) return this._data;
+        return safeGet(this._data, key);
+    },
+    map: function(from, to, fn) {
+        if (isFn(from)) return this.set(map(this._data, from, this));
+        if (isFn(to)) {
+            fn = to;
+            to = from;
+        }
+        return this.set(to, map(this.get(from), fn, this));
+    },
+    filter: function(from, to, fn) {
+        if (isFn(from)) return this.set(filter(this._data, from, this));
+        if (isFn(to)) {
+            fn = to;
+            to = from;
+        }
+        return this.set(to, filter(this.get(from), fn, this));
+    },
+    remove: function(keys) {
+        keys = toArr(keys);
+        var data = this._data;
+        each(keys, function(key) {
+            safeDel(data, key);
+        });
+        return this;
+    },
+    compute: function(from, to, fn) {
+        if (isFn(from)) return this.set(from.call(this, this._data));
+        if (isFn(to)) return this.set(from, to.call(this, this.get(from)));
+        from = map(
+            toArr(from),
+            function(key) {
+                return safeGet(this._data, key);
+            },
+            this
+        );
+        return this.set(to, fn.apply(this, from));
+    },
+    toString: function() {
+        return JSON.stringify(this._data);
+    }
+});
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/LinkedList.d.ts

@@ -0,0 +1,24 @@
+import types = require('./types');
+
+declare namespace LinkedList {
+    class Node {
+        value: any;
+        prev: Node | null;
+        next: Node | null;
+    }
+}
+declare class LinkedList {
+    size: number;
+    head: LinkedList.Node;
+    tail: LinkedList.Node;
+    push(val: any): number;
+    pop(): any;
+    unshift(val: any): number;
+    shift(): any;
+    find(fn: types.AnyFn): LinkedList.Node | void;
+    delNode(node: LinkedList.Node): void;
+    forEach(iterator: types.AnyFn, ctx?: any);
+    toArr(): any[];
+}
+
+export = LinkedList;

uni_modules/UniDevTools/node_modules/licia/LinkedList.js

@@ -0,0 +1,112 @@
+var Class = require('./Class');
+exports = Class({
+    initialize: function LinkedList() {
+        this.tail = null;
+        this.head = null;
+        this.size = 0;
+    },
+    push: function(val) {
+        var node = new Node(val, this.tail, null, this);
+        this.tail = node;
+        this.head = this.head || node;
+        this.size++;
+        return this.size;
+    },
+    pop: function() {
+        if (!this.tail) return;
+        var node = this.tail;
+        this.tail = node.prev;
+        if (this.tail) {
+            this.tail.next = null;
+        } else {
+            this.head = null;
+        }
+        this.size--;
+        return node.value;
+    },
+    unshift: function(val) {
+        var node = new Node(val, null, this.head, this);
+        this.head = node;
+        this.tail = this.tail || node;
+        this.size++;
+        return this.size;
+    },
+    shift: function() {
+        if (!this.head) return;
+        var node = this.head;
+        this.head = node.next;
+        if (this.head) {
+            this.head.prev = null;
+        } else {
+            this.tail = null;
+        }
+        this.size--;
+        return node.value;
+    },
+    rmNode: function(node) {
+        if (node.list !== this) {
+            throw Error('Node does not belong to this list');
+        }
+        var next = node.next,
+            prev = node.prev;
+        if (next) {
+            next.prev = prev;
+        }
+        if (prev) {
+            prev.next = next;
+        }
+        if (node === this.head) {
+            this.head = next;
+        }
+        if (node === this.tail) {
+            this.tail = prev;
+        }
+        node.list = null;
+        node.prev = null;
+        node.next = null;
+        this.size--;
+    },
+    find: function(fn) {
+        for (var i = 0, current = this.head; current !== null; i++) {
+            if (fn(current.value)) {
+                return current;
+            }
+            current = current.next;
+        }
+    },
+    forEach: function(iterator, ctx) {
+        ctx = arguments.length > 1 ? ctx : this;
+        for (var i = 0, current = this.head; current !== null; i++) {
+            iterator.call(ctx, current.value, i, this);
+            current = current.next;
+        }
+    },
+    toArr: function() {
+        var arr = new Array(this.size);
+        for (var i = 0, current = this.head; current !== null; i++) {
+            arr[i] = current.value;
+            current = current.next;
+        }
+        return arr;
+    }
+});
+var Node = (exports.Node = Class({
+    initialize: function Node(val, prev, next, list) {
+        this.value = val;
+        this.list = list;
+        if (prev) {
+            prev.next = this;
+            this.prev = prev;
+        } else {
+            this.prev = null;
+        }
+        if (next) {
+            next.prev = this;
+            this.next = next;
+        } else {
+            this.next = null;
+        }
+    }
+}));
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/LocalStore.d.ts

@@ -0,0 +1,7 @@
+import Store = require('./Store');
+
+declare class LocalStore extends Store {
+    constructor(name: string, data?: {});
+}
+
+export = LocalStore;

uni_modules/UniDevTools/node_modules/licia/LocalStore.js

@@ -0,0 +1,28 @@
+var Store = require('./Store');
+var safeStorage = require('./safeStorage');
+var isEmpty = require('./isEmpty');
+var stringify = require('./stringify');
+var defaults = require('./defaults');
+var isObj = require('./isObj');
+var localStorage = safeStorage('local');
+exports = Store.extend({
+    initialize: function LocalStore(name, data) {
+        this._name = name;
+        data = data || {};
+        var localData = localStorage.getItem(name);
+        try {
+            localData = JSON.parse(localData);
+        } catch (e) {
+            localData = {};
+        }
+        if (!isObj(localData)) localData = {};
+        data = defaults(localData, data);
+        this.callSuper(Store, 'initialize', [data]);
+    },
+    save: function(data) {
+        if (isEmpty(data)) return localStorage.removeItem(this._name);
+        localStorage.setItem(this._name, stringify(data));
+    }
+});
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/Logger.d.ts

@@ -0,0 +1,18 @@
+import Emitter = require('./Emitter');
+import Enum = require('./Enum');
+
+declare class Logger extends Emitter {
+    name: string;
+    formatter(type: string, argList: any[]): any[];
+    constructor(name: string, level?: string | number);
+    setLevel(level: string | number): Logger;
+    getLevel(): number;
+    trace(...args: any[]): Logger;
+    debug(...args: any[]): Logger;
+    info(...args: any[]): Logger;
+    warn(...args: any[]): Logger;
+    error(...args: any[]): Logger;
+    static level: Enum;
+}
+
+export = Logger;

uni_modules/UniDevTools/node_modules/licia/Logger.js

@@ -0,0 +1,69 @@
+var Emitter = require('./Emitter');
+var Enum = require('./Enum');
+var toArr = require('./toArr');
+var isUndef = require('./isUndef');
+var clone = require('./clone');
+var isStr = require('./isStr');
+var isNum = require('./isNum');
+exports = Emitter.extend(
+    {
+        initialize: function Logger(name, level) {
+            this.name = name;
+            this.setLevel(isUndef(level) ? exports.level.DEBUG : level);
+            this.callSuper(Emitter, 'initialize', arguments);
+        },
+        setLevel: function(level) {
+            if (isStr(level)) {
+                level = exports.level[level.toUpperCase()];
+                if (level) this._level = level;
+                return this;
+            }
+            if (isNum(level)) this._level = level;
+            return this;
+        },
+        getLevel: function() {
+            return this._level;
+        },
+        formatter: function(type, argList) {
+            return argList;
+        },
+        trace: function() {
+            return this._log('trace', arguments);
+        },
+        debug: function() {
+            return this._log('debug', arguments);
+        },
+        info: function() {
+            return this._log('info', arguments);
+        },
+        warn: function() {
+            return this._log('warn', arguments);
+        },
+        error: function() {
+            return this._log('error', arguments);
+        },
+        _log: function(type, argList) {
+            argList = toArr(argList);
+            if (argList.length === 0) return this;
+            this.emit('all', type, clone(argList));
+            if (exports.level[type.toUpperCase()] < this._level) return this;
+            this.emit(type, clone(argList));
+
+            var consoleMethod = type === 'debug' ? console.log : console[type];
+            consoleMethod.apply(console, this.formatter(type, argList));
+            return this;
+        }
+    },
+    {
+        level: new Enum({
+            TRACE: 0,
+            DEBUG: 1,
+            INFO: 2,
+            WARN: 3,
+            ERROR: 4,
+            SILENT: 5
+        })
+    }
+);
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/Lru.d.ts

@@ -0,0 +1,10 @@
+declare class Lru {
+    constructor(max: number);
+    has(key: string): boolean;
+    remove(key: string): void;
+    get(key: string): any;
+    set(key: string, val: any): void;
+    clear(): void;
+}
+
+export = Lru;

uni_modules/UniDevTools/node_modules/licia/Lru.js

@@ -0,0 +1,63 @@
+var LinkedList = require('./LinkedList');
+var PseudoMap = require('./PseudoMap');
+var Class = require('./Class');
+exports = Class({
+    initialize: function Lru(max) {
+        this._max = max;
+        this._list = new LinkedList();
+        this._map = new PseudoMap();
+    },
+    has: function(key) {
+        return this._map.has(key);
+    },
+    remove: function(key) {
+        var map = this._map;
+        if (this.has(key)) {
+            var node = map.get(key);
+            this._list.rmNode(node);
+            map.delete(key);
+        }
+    },
+    get: function(key) {
+        var list = this._list;
+        var map = this._map;
+        var ret;
+        if (this.has(key)) {
+            var node = map.get(key);
+            ret = node.value.val;
+            list.rmNode(node);
+            list.unshift(node.value);
+            map.set(key, list.head);
+        }
+        return ret;
+    },
+    set: function(key, val) {
+        var list = this._list;
+        var map = this._map;
+        if (this.has(key)) {
+            var node = map.get(key);
+            list.rmNode(node);
+            list.unshift({
+                key: key,
+                val: val
+            });
+            map.set(key, list.head);
+        } else {
+            list.unshift({
+                key: key,
+                val: val
+            });
+            map.set(key, list.head);
+            if (list.size > this._max) {
+                var item = list.pop();
+                map.delete(item.key);
+            }
+        }
+    },
+    clear: function() {
+        this._map = new PseudoMap();
+        this._list = new LinkedList();
+    }
+});
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/MediaQuery.d.ts

@@ -0,0 +1,9 @@
+import Emitter = require('./Emitter');
+
+declare class MediaQuery extends Emitter {
+    constructor(query: string);
+    setQuery(query: string): void;
+    isMatch(): boolean;
+}
+
+export = MediaQuery;

uni_modules/UniDevTools/node_modules/licia/MediaQuery.js

@@ -0,0 +1,24 @@
+var Emitter = require('./Emitter');
+exports = Emitter.extend({
+    className: 'MediaQuery',
+    initialize: function(query) {
+        var _this = this;
+        this.callSuper(Emitter, 'initialize');
+        this._listener = function() {
+            _this.emit(_this.isMatch() ? 'match' : 'unmatch');
+        };
+        this.setQuery(query);
+    },
+    setQuery: function(query) {
+        if (this._mql) {
+            this._mql.removeListener(this._listener);
+        }
+        this._mql = window.matchMedia(query);
+        this._mql.addListener(this._listener);
+    },
+    isMatch: function() {
+        return this._mql.matches;
+    }
+});
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/MutationObserver.d.ts

@@ -0,0 +1 @@
+export = MutationObserver;

uni_modules/UniDevTools/node_modules/licia/MutationObserver.js

@@ -0,0 +1,15 @@
+var Class = require('./Class');
+exports =
+    window.MutationObserver ||
+    window.WebKitMutationObserver ||
+    window.MozMutationObserver;
+if (!exports) {
+    exports = Class({
+        initialize: function MutationObserver() {},
+        observe: function() {},
+        disconnect: function() {},
+        takeRecords: function() {}
+    });
+}
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/PriorityQueue.d.ts

@@ -0,0 +1,12 @@
+import types = require('./types');
+
+declare class PriorityQueue {
+    size: number;
+    constructor(cmp?: types.AnyFn);
+    clear(): void;
+    enqueue(item: any): number;
+    dequeue(): any;
+    peek(): any;
+}
+
+export = PriorityQueue;

uni_modules/UniDevTools/node_modules/licia/PriorityQueue.js

@@ -0,0 +1,39 @@
+var Class = require('./Class');
+var Heap = require('./Heap');
+var isSorted = require('./isSorted');
+var wrap = require('./wrap');
+exports = Class({
+    initialize: function PriorityQueue() {
+        var cmp =
+            arguments.length > 0 && arguments[0] !== undefined
+                ? arguments[0]
+                : isSorted.defComparator;
+        this._heap = new Heap(
+            wrap(cmp, function(fn, a, b) {
+                return fn(a, b) * -1;
+            })
+        );
+        this.size = 0;
+    },
+    clear: function() {
+        this._heap.clear();
+        this.size = 0;
+    },
+    enqueue: function(item) {
+        this._heap.add(item);
+        this.size++;
+        return this.size;
+    },
+    dequeue: function() {
+        var item = this._heap.poll();
+        if (item) {
+            this.size--;
+            return item;
+        }
+    },
+    peek: function() {
+        return this._heap.peek();
+    }
+});
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/Promise.d.ts

@@ -0,0 +1 @@
+export = Promise;

uni_modules/UniDevTools/node_modules/licia/Promise.js

@@ -0,0 +1,178 @@
+var Class = require('./Class');
+var isObj = require('./isObj');
+var isFn = require('./isFn');
+var State = require('./State');
+var bind = require('./bind');
+var nextTick = require('./nextTick');
+var noop = require('./noop');
+var toArr = require('./toArr');
+var Promise = (exports = Class(
+    {
+        initialize: function Promise(fn) {
+            if (!isObj(this))
+                throw new TypeError('Promises must be constructed via new');
+            if (!isFn(fn)) throw new TypeError(fn + ' is not a function');
+            var self = this;
+            this._state = new State('pending', {
+                fulfill: {
+                    from: 'pending',
+                    to: 'fulfilled'
+                },
+                reject: {
+                    from: 'pending',
+                    to: 'rejected'
+                },
+                adopt: {
+                    from: 'pending',
+                    to: 'adopted'
+                }
+            })
+                .on('fulfill', assignVal)
+                .on('reject', assignVal)
+                .on('adopt', assignVal);
+            function assignVal(val) {
+                self._value = val;
+            }
+            this._handled = false;
+            this._value = undefined;
+            this._deferreds = [];
+            doResolve(fn, this);
+        },
+        catch: function(onRejected) {
+            return this.then(null, onRejected);
+        },
+        then: function(onFulfilled, onRejected) {
+            var promise = new Promise(noop);
+            handle(this, new Handler(onFulfilled, onRejected, promise));
+            return promise;
+        }
+    },
+    {
+        all: function(arr) {
+            var args = toArr(arr);
+            return new Promise(function(resolve, reject) {
+                if (args.length === 0) return resolve([]);
+                var remaining = args.length;
+                function res(i, val) {
+                    try {
+                        if (val && (isObj(val) || isFn(val))) {
+                            var then = val.then;
+                            if (isFn(then)) {
+                                then.call(
+                                    val,
+                                    function(val) {
+                                        res(i, val);
+                                    },
+                                    reject
+                                );
+                                return;
+                            }
+                        }
+                        args[i] = val;
+                        if (--remaining === 0) resolve(args);
+                    } catch (e) {
+                        reject(e);
+                    }
+                }
+                for (var i = 0; i < args.length; i++) res(i, args[i]);
+            });
+        },
+        resolve: function(val) {
+            if (val && isObj(val) && val.constructor === Promise) return val;
+            return new Promise(function(resolve) {
+                resolve(val);
+            });
+        },
+        reject: function(val) {
+            return new Promise(function(resolve, reject) {
+                reject(val);
+            });
+        },
+        race: function(values) {
+            return new Promise(function(resolve, reject) {
+                for (var i = 0, len = values.length; i < len; i++) {
+                    values[i].then(resolve, reject);
+                }
+            });
+        }
+    }
+));
+var Handler = Class({
+    initialize: function Handler(onFulfilled, onRejected, promise) {
+        this.onFulfilled = isFn(onFulfilled) ? onFulfilled : null;
+        this.onRejected = isFn(onRejected) ? onRejected : null;
+        this.promise = promise;
+    }
+});
+function reject(self, err) {
+    self._state.reject(err);
+    finale(self);
+}
+function resolve(self, val) {
+    try {
+        if (val === self)
+            throw new TypeError('A promise cannot be resolved with itself');
+        if (val && (isObj(val) || isFn(val))) {
+            var then = val.then;
+            if (val instanceof Promise) {
+                self._state.adopt(val);
+                return finale(self);
+            }
+            if (isFn(then)) return doResolve(bind(then, val), self);
+        }
+        self._state.fulfill(val);
+        finale(self);
+    } catch (e) {
+        reject(self, e);
+    }
+}
+function finale(self) {
+    for (var i = 0, len = self._deferreds.length; i < len; i++) {
+        handle(self, self._deferreds[i]);
+    }
+    self._deferreds = null;
+}
+function handle(self, deferred) {
+    while (self._state.is('adopted')) self = self._value;
+    if (self._state.is('pending')) return self._deferreds.push(deferred);
+    self._handled = true;
+    nextTick(function() {
+        var isFulfilled = self._state.is('fulfilled');
+        var cb = isFulfilled ? deferred.onFulfilled : deferred.onRejected;
+        if (cb === null)
+            return (isFulfilled ? resolve : reject)(
+                deferred.promise,
+                self._value
+            );
+        var ret;
+        try {
+            ret = cb(self._value);
+        } catch (e) {
+            return reject(deferred.promise, e);
+        }
+        resolve(deferred.promise, ret);
+    });
+}
+function doResolve(fn, self) {
+    var done = false;
+    try {
+        fn(
+            function(val) {
+                if (done) return;
+                done = true;
+                resolve(self, val);
+            },
+            function(reason) {
+                if (done) return;
+                done = true;
+                reject(self, reason);
+            }
+        );
+    } catch (e) {
+        if (done) return;
+        done = true;
+        reject(self, e);
+    }
+}
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/PseudoMap.d.ts

@@ -0,0 +1,3 @@
+declare const PseudoMap: typeof Map;
+
+export = PseudoMap;

uni_modules/UniDevTools/node_modules/licia/PseudoMap.js

@@ -0,0 +1,64 @@
+var Class = require('./Class');
+var root = require('./root');
+var defineProp = require('./defineProp');
+var keys = require('./keys');
+var each = require('./each');
+var isArr = require('./isArr');
+var isUndef = require('./isUndef');
+if (root.Map && !false) {
+    exports = root.Map;
+} else {
+    exports = Class({
+        initialize: function PseudoMap(data) {
+            this.clear();
+            var self = this;
+            defineProp(this, 'size', {
+                get: function() {
+                    return keys(self._data).length;
+                },
+                set: function() {},
+                enumerable: true,
+                configurable: true
+            });
+            if (data instanceof exports) {
+                data.forEach(function(val, key) {
+                    this.set(key, val);
+                }, this);
+            } else if (isArr(data)) {
+                each(
+                    data,
+                    function(val) {
+                        this.set(val[0], val[1]);
+                    },
+                    this
+                );
+            }
+        },
+        forEach: function(fn, ctx) {
+            each(
+                this._data,
+                function(val, key) {
+                    fn.call(this, val, key);
+                },
+                ctx
+            );
+        },
+        has: function(key) {
+            return !isUndef(this._data[key]);
+        },
+        get: function(key) {
+            return this._data[key];
+        },
+        set: function(key, val) {
+            this._data[key] = val;
+        },
+        delete: function(key) {
+            delete this._data[key];
+        },
+        clear: function() {
+            this._data = {};
+        }
+    });
+}
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/Queue.d.ts

@@ -0,0 +1,13 @@
+import types = require('./types');
+
+declare class Queue {
+    size: number;
+    clear(): void;
+    enqueue(item: any): number;
+    dequeue(): any;
+    peek(): any;
+    forEach(iterator: types.AnyFn, context?: any): void;
+    toArr(): any[];
+}
+
+export = Queue;

uni_modules/UniDevTools/node_modules/licia/Queue.js

@@ -0,0 +1,35 @@
+var Class = require('./Class');
+exports = Class({
+    initialize: function Queue() {
+        this.clear();
+    },
+    clear: function() {
+        this._items = [];
+        this.size = 0;
+    },
+    enqueue: function(item) {
+        this._items.push(item);
+        return ++this.size;
+    },
+    dequeue: function() {
+        if (!this.size) return;
+        this.size--;
+        return this._items.shift();
+    },
+    peek: function() {
+        if (!this.size) return;
+        return this._items[0];
+    },
+    forEach: function(iterator, ctx) {
+        ctx = arguments.length > 1 ? ctx : this;
+        var items = this._items;
+        for (var i = 0, size = this.size; i < size; i++) {
+            iterator.call(ctx, items[i], i, this);
+        }
+    },
+    toArr: function() {
+        return this._items.slice(0);
+    }
+});
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/QuickLru.d.ts

@@ -0,0 +1,10 @@
+declare class QuickLru {
+    constructor(max: number);
+    has(key: string): boolean;
+    remove(key: string): void;
+    get(key: string): any;
+    set(key: string, val: any): void;
+    clear(): void;
+}
+
+export = QuickLru;

uni_modules/UniDevTools/node_modules/licia/QuickLru.js

@@ -0,0 +1,49 @@
+var isUndef = require('./isUndef');
+var Class = require('./Class');
+exports = Class({
+    initialize: function QuickLru(max) {
+        this._max = max;
+        this._cache = {};
+        this._oldCache = {};
+        this._size = 0;
+    },
+    has: function(key) {
+        return !isUndef(this._cache[key]) || !isUndef(this._oldCache[key]);
+    },
+    remove: function(key) {
+        if (!isUndef(this._cache[key])) this._cache[key] = undefined;
+        if (!isUndef(this._oldCache[key])) this._oldCache[key] = undefined;
+    },
+    get: function(key) {
+        if (!isUndef(this._cache[key])) {
+            return this._cache[key];
+        }
+        var val = this._oldCache[key];
+        if (!isUndef(val)) {
+            this._update(key, val);
+            return val;
+        }
+    },
+    set: function(key, val) {
+        if (!isUndef(this._cache[key])) {
+            this._cache[key] = val;
+        } else {
+            this._update(key, val);
+        }
+    },
+    clear: function() {
+        this._cache = {};
+        this._oldCache = {};
+    },
+    _update: function(key, val) {
+        this._cache[key] = val;
+        this._size++;
+        if (this._size > this._max) {
+            this._size = 0;
+            this._oldCache = this._cache;
+            this._cache = {};
+        }
+    }
+});
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/README.md

@@ -0,0 +1,57 @@
+[中文](README_CN.md)
+
+# Licia
+
+[![NPM version][npm-image]][npm-url]
+[![Build status][ci-image]][ci-url]
+[![Test coverage][codecov-image]][codecov-url]
+[![Size][size-image]][npm-url]
+[![License][license-image]][npm-url]
+[![Join the chat at https://gitter.im/liriliri/licia][gitter-image]][gitter-url]
+
+[gitter-image]: https://img.shields.io/gitter/room/liriliri/licia?style=flat-square
+[gitter-url]: https://gitter.im/liriliri/licia?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
+[npm-image]: https://img.shields.io/npm/v/licia?style=flat-square 
+[npm-url]: https://npmjs.org/package/licia
+[ci-image]: https://img.shields.io/github/actions/workflow/status/liriliri/licia/main.yml?branch=master&style=flat-square
+[ci-url]: https://github.com/liriliri/licia/actions/workflows/main.yml
+[codecov-image]: https://img.shields.io/codecov/c/github/liriliri/licia?style=flat-square
+[codecov-url]: https://codecov.io/github/liriliri/licia?branch=master
+[license-image]: https://img.shields.io/npm/l/licia?style=flat-square
+[size-image]: https://img.shields.io/bundlephobia/minzip/licia?style=flat-square
+
+[Licia](https://licia.liriliri.io/) is a utility library that focus on getting daily works done. Unlike other libraries such as underscore, mout, which strictly separates its functions into several categories like array, string and function etc. licia is just a deadly simple collection of over 400 micro modules dealing problems in different aspects. 
+
+## Benefits
+
+Installing one library brings you tons of useful utilities: 
+
+* A dom module with jQuery coding style. 
+* A cookie library. 
+* dateFormat that is good enough to handle most date related work.
+* A Promise polyfill. 
+* A micro event emitter library. 
+* Ajax and its Promise version fetch.
+* Useful functions from underscore, such as shuffle, unique. 
+* mkdir, like mkdirp the module that has many dependents in npm.
+* ...
+
+## Usage
+
+Just install **licia** and use it like any other npm utility modules such as lodash.
+
+```bash
+npm i licia --save
+```
+
+```javascript
+const uuid = require('licia/uuid');
+
+console.log(uuid()); // -> 0e3b84af-f911-4a55-b78a-cedf6f0bd815
+```
+
+Looking for Licia modules written in ES6 or smaller bundle sizes? Check out [licia-es](https://www.npmjs.com/package/licia-es). There is also an online tool to build a customized utility library, check [here](https://licia.liriliri.io/builder.html).
+
+## Contribution
+
+Read [Contributing Guide](.github/CONTRIBUTING.md) for development setup instructions.

uni_modules/UniDevTools/node_modules/licia/Readiness.d.ts

@@ -0,0 +1,9 @@
+import types = require('./types');
+
+declare class Readiness {
+    signal(tasks: string | string[]): void;
+    isReady(tasks: string | string[]): boolean;
+    ready(tasks: string | string[], fn?: types.AnyFn): Promise<void>;
+}
+
+export = Readiness;

uni_modules/UniDevTools/node_modules/licia/Readiness.js

@@ -0,0 +1,59 @@
+var Class = require('./Class');
+var toArr = require('./toArr');
+var each = require('./each');
+var map = require('./map');
+var noop = require('./noop');
+var some = require('./some');
+exports = Class({
+    initialize: function Readiness() {
+        this._promises = {};
+        this._resolves = {};
+        this._states = {};
+    },
+    signal: function(tasks) {
+        var states = this._states;
+        each(this._getPromises(toArr(tasks)), function(val) {
+            if (!val.state) {
+                states[val.task] = true;
+                val.resolve();
+            }
+        });
+    },
+    isReady: function(tasks) {
+        return !some(this._getPromises(toArr(tasks)), function(val) {
+            return !val.state;
+        });
+    },
+    ready: function(tasks) {
+        var fn =
+            arguments.length > 1 && arguments[1] !== undefined
+                ? arguments[1]
+                : noop;
+        return Promise.all(
+            map(this._getPromises(toArr(tasks)), function(val) {
+                return val.promise;
+            })
+        ).then(fn);
+    },
+    _getPromises: function(tasks) {
+        var promises = this._promises;
+        var resolves = this._resolves;
+        var states = this._states;
+        return map(tasks, function(task) {
+            if (!promises[task]) {
+                promises[task] = new Promise(function(resolve) {
+                    resolves[task] = resolve;
+                    states[task] = false;
+                });
+            }
+            return {
+                task: task,
+                promise: promises[task],
+                resolve: resolves[task],
+                state: states[task]
+            };
+        });
+    }
+});
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/ReduceStore.d.ts

@@ -0,0 +1,10 @@
+import types = require('./types');
+
+declare class ReduceStore {
+    constructor(reducer: types.AnyFn, initialState: any);
+    subscribe(listener: types.AnyFn): types.AnyFn;
+    dispatch(action: any): any;
+    getState(): any;
+}
+
+export = ReduceStore;

uni_modules/UniDevTools/node_modules/licia/ReduceStore.js

@@ -0,0 +1,41 @@
+var Class = require('./Class');
+var clone = require('./clone');
+var remove = require('./remove');
+exports = Class({
+    initialize: function ReduceStore(reducer, initialState) {
+        this._reducer = reducer;
+        this._state = initialState;
+        this._curListeners = [];
+        this._nextListeners = this._curListeners;
+    },
+    subscribe: function(listener) {
+        var isSubscribed = true;
+        this._ensureCanMutateNextListeners();
+        this._nextListeners.push(listener);
+        var self = this;
+        return function() {
+            if (!isSubscribed) return;
+            isSubscribed = false;
+            self._ensureCanMutateNextListeners();
+            remove(self._nextListeners, function(val) {
+                return val === listener;
+            });
+        };
+    },
+    dispatch: function(action) {
+        this._state = this._reducer(this._state, action);
+        var listeners = (this._curListeners = this._nextListeners);
+        for (var i = 0, len = listeners.length; i < len; i++) listeners[i]();
+        return action;
+    },
+    getState: function() {
+        return this._state;
+    },
+    _ensureCanMutateNextListeners: function() {
+        if (this._nextListeners === this._curListeners) {
+            this._nextListeners = clone(this._curListeners);
+        }
+    }
+});
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/ResizeSensor.d.ts

@@ -0,0 +1,9 @@
+import SingleEmitter = require('./SingleEmitter');
+import extend = require('./extend');
+
+declare class ResizeSensor extends SingleEmitter {
+    constructor(el: HTMLElement);
+    destroy(): void;
+}
+
+export = ResizeSensor;

uni_modules/UniDevTools/node_modules/licia/ResizeSensor.js

@@ -0,0 +1,157 @@
+var SingleEmitter = require('./SingleEmitter');
+var h = require('./h');
+var $event = require('./$event');
+var $css = require('./$css');
+var contain = require('./contain');
+var extend = require('./extend');
+var root = require('./root');
+if (root.ResizeObserver && !false) {
+    exports = SingleEmitter.extend({
+        initialize: function ResizeSensor(el) {
+            var _this = this;
+            if (el._resizeSensor) {
+                return el._resizeSensor;
+            }
+            this.callSuper(SingleEmitter, 'initialize');
+            var resizeObserver = new root.ResizeObserver(function() {
+                return _this.emit();
+            });
+            resizeObserver.observe(el);
+            el._resizeSensor = this;
+            this._resizeObserver = resizeObserver;
+            this._el = el;
+        },
+        destroy: function() {
+            var el = this._el;
+            if (!el._resizeSensor) {
+                return;
+            }
+            this.rmAllListeners();
+            delete el._resizeSensor;
+            this._resizeObserver.unobserve(el);
+        }
+    });
+} else {
+    exports = SingleEmitter.extend({
+        initialize: function ResizeSensor(el) {
+            if (el._resizeSensor) {
+                return el._resizeSensor;
+            }
+            this.callSuper(SingleEmitter, 'initialize');
+            this._el = el;
+            el._resizeSensor = this;
+            if (
+                !contain(
+                    ['absolute', 'relative', 'fixed', 'sticky'],
+                    $css(el, 'position')
+                )
+            ) {
+                $css(el, 'position', 'relative');
+            }
+            this._appendResizeSensor();
+            this._bindEvent();
+        },
+        destroy: function() {
+            var el = this._el;
+            if (!el._resizeSensor) {
+                return;
+            }
+            this.rmAllListeners();
+            delete el._resizeSensor;
+            el.removeChild(this._resizeSensorEl);
+        },
+        _appendResizeSensor: function() {
+            var el = this._el;
+            var style = {
+                pointerEvents: 'none',
+                position: 'absolute',
+                left: '0px',
+                top: '0px',
+                right: '0px',
+                bottom: '0px',
+                overflow: 'hidden',
+                zIndex: '-1',
+                visibility: 'hidden',
+                maxWidth: '100%'
+            };
+            var styleChild = {
+                position: 'absolute',
+                left: '0px',
+                top: '0px',
+                transition: '0s'
+            };
+            var expandChildEl = h('div', {
+                style: styleChild
+            });
+            var expandEl = h(
+                'div.resize-sensor-expand',
+                {
+                    style: style
+                },
+                expandChildEl
+            );
+            var shrinkEl = h(
+                'div.resize-sensor-shrink',
+                {
+                    style: style
+                },
+                h('div', {
+                    style: extend(
+                        {
+                            width: '200%',
+                            height: '200%'
+                        },
+                        styleChild
+                    )
+                })
+            );
+            var resizeSensorEl = h(
+                'div.resize-sensor',
+                {
+                    dir: 'ltr',
+                    style: style
+                },
+                expandEl,
+                shrinkEl
+            );
+            this._expandEl = expandEl;
+            this._expandChildEl = expandChildEl;
+            this._shrinkEl = shrinkEl;
+            this._resizeSensorEl = resizeSensorEl;
+            el.appendChild(resizeSensorEl);
+            this._resetExpandShrink();
+        },
+        _bindEvent: function() {
+            var _this2 = this;
+            $event.on(this._expandEl, 'scroll', function() {
+                return _this2._onScroll();
+            });
+            $event.on(this._shrinkEl, 'scroll', function() {
+                return _this2._onScroll();
+            });
+        },
+        _onScroll: function() {
+            this.emit();
+            this._resetExpandShrink();
+        },
+        _resetExpandShrink: function() {
+            var el = this._el;
+            var width = el.offsetWidth;
+            var height = el.offsetHeight;
+            $css(this._expandChildEl, {
+                width: width + 10,
+                height: height + 10
+            });
+            extend(this._expandEl, {
+                scrollLeft: width + 10,
+                scrollTop: height + 10
+            });
+            extend(this._shrinkEl, {
+                scrollLeft: width + 10,
+                scrollTop: height + 10
+            });
+        }
+    });
+}
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/Select.d.ts

@@ -0,0 +1,10 @@
+import each = require('./each');
+import types = require('./types');
+
+declare class Select {
+    constructor(selector: string | Element | Document);
+    find(selector: string): Select;
+    each(fn: types.AnyFn): Select;
+}
+
+export = Select;

uni_modules/UniDevTools/node_modules/licia/Select.js

@@ -0,0 +1,32 @@
+var Class = require('./Class');
+var isStr = require('./isStr');
+var each = require('./each');
+var mergeArr = require('./mergeArr');
+exports = Class({
+    className: 'Select',
+    initialize: function(selector) {
+        this.length = 0;
+        if (!selector) return this;
+        if (isStr(selector)) return rootSelect.find(selector);
+        if (selector.nodeType) {
+            this[0] = selector;
+            this.length = 1;
+        }
+    },
+    find: function(selector) {
+        var ret = new exports();
+        this.each(function() {
+            mergeArr(ret, this.querySelectorAll(selector));
+        });
+        return ret;
+    },
+    each: function(fn) {
+        each(this, function(element, idx) {
+            fn.call(element, idx, element);
+        });
+        return this;
+    }
+});
+var rootSelect = new exports(document);
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/Semaphore.d.ts

@@ -0,0 +1,7 @@
+declare class Semaphore {
+    constructor(counter?: number);
+    wait(fn: () => void): void;
+    signal(): void;
+}
+
+export = Semaphore;

uni_modules/UniDevTools/node_modules/licia/Semaphore.js

@@ -0,0 +1,28 @@
+var Class = require('./Class');
+var Queue = require('./Queue');
+exports = Class({
+    initialize: function Semaphore() {
+        var counter =
+            arguments.length > 0 && arguments[0] !== undefined
+                ? arguments[0]
+                : 1;
+        this._counter = counter;
+        this._tasks = new Queue();
+    },
+    wait: function(fn) {
+        if (this._counter > 0) {
+            this._counter--;
+            return fn();
+        }
+        this._tasks.enqueue(fn);
+    },
+    signal: function() {
+        var task = this._tasks.dequeue();
+        if (task) {
+            return task();
+        }
+        this._counter++;
+    }
+});
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/SessionStore.d.ts

@@ -0,0 +1,7 @@
+import Store = require('./Store');
+
+declare class SessionStore extends Store {
+    constructor(name: string, data?: any);
+}
+
+export = SessionStore;

uni_modules/UniDevTools/node_modules/licia/SessionStore.js

@@ -0,0 +1,28 @@
+var Store = require('./Store');
+var safeStorage = require('./safeStorage');
+var isEmpty = require('./isEmpty');
+var stringify = require('./stringify');
+var defaults = require('./defaults');
+var isObj = require('./isObj');
+var sessionStorage = safeStorage('session');
+exports = Store.extend({
+    initialize: function SessionStore(name, data) {
+        this._name = name;
+        data = data || {};
+        var sessionData = sessionStorage.getItem(name);
+        try {
+            sessionData = JSON.parse(sessionData);
+        } catch (e) {
+            sessionData = {};
+        }
+        if (!isObj(sessionData)) sessionData = {};
+        data = defaults(sessionData, data);
+        this.callSuper(Store, 'initialize', [data]);
+    },
+    save: function(data) {
+        if (isEmpty(data)) return sessionStorage.removeItem(this._name);
+        sessionStorage.setItem(this._name, stringify(data));
+    }
+});
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/SingleEmitter.d.ts

@@ -0,0 +1,11 @@
+import types = require('./types');
+
+declare class SingleEmitter {
+    addListener(listener: types.AnyFn): void;
+    rmListener(listener: types.AnyFn): void;
+    emit(...args: any[]): void;
+    rmAllListeners(): void;
+    static mixin(obj: any): void;
+}
+
+export = SingleEmitter;

uni_modules/UniDevTools/node_modules/licia/SingleEmitter.js

@@ -0,0 +1,48 @@
+var Class = require('./Class');
+var clone = require('./clone');
+var each = require('./each');
+var toArr = require('./toArr');
+exports = Class(
+    {
+        initialize: function SingleEmitter() {
+            this._listeners = [];
+        },
+        addListener: function(listener) {
+            this._listeners.push(listener);
+        },
+        rmListener: function(listener) {
+            var idx = this._listeners.indexOf(listener);
+            if (idx > -1) {
+                this._listeners.splice(idx, 1);
+            }
+        },
+        rmAllListeners: function() {
+            this._listeners = [];
+        },
+        emit: function() {
+            var _this = this;
+            var args = toArr(arguments);
+            var listeners = clone(this._listeners);
+            each(
+                listeners,
+                function(listener) {
+                    return listener.apply(_this, args);
+                },
+                this
+            );
+        }
+    },
+    {
+        mixin: function(obj) {
+            each(
+                ['addListener', 'rmListener', 'emit', 'rmAllListeners'],
+                function(val) {
+                    obj[val] = exports.prototype[val];
+                }
+            );
+            obj._listeners = obj._listeners || [];
+        }
+    }
+);
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/Socket.d.ts

@@ -0,0 +1,16 @@
+import Emitter = require('./Emitter');
+
+declare class Socket extends Emitter {
+    constructor(
+        url: string,
+        options?: {
+            protocols?: string | string[];
+            reconnect?: boolean;
+        }
+    );
+    send(message: any): void;
+    close(code?: number, reason?: string): void;
+    connect(): void;
+}
+
+export = Socket;

uni_modules/UniDevTools/node_modules/licia/Socket.js

@@ -0,0 +1,58 @@
+var defaults = require('./defaults');
+var Emitter = require('./Emitter');
+exports = Emitter.extend({
+    initialize: function Socket(url) {
+        var options =
+            arguments.length > 1 && arguments[1] !== undefined
+                ? arguments[1]
+                : {};
+        this.callSuper(Emitter, 'initialize');
+        defaults(options, defOpts);
+        this._options = options;
+        this._url = url;
+        this.connect();
+    },
+    send: function(message) {
+        this._ws.send(message);
+    },
+    close: function(code, reason) {
+        this._ws.close(code || 1e3, reason);
+    },
+    connect: function() {
+        var _this = this;
+        var options = this._options;
+        var ws = new WebSocket(this._url, options.protocols);
+        ws.onmessage = function(e) {
+            return _this.emit('message', e);
+        };
+        ws.onopen = function(e) {
+            return _this.emit('open', e);
+        };
+        ws.onclose = function(e) {
+            var code = e.code;
+            if (
+                code !== 1e3 &&
+                code !== 1001 &&
+                code !== 1005 &&
+                options.reconnect
+            ) {
+                _this.connect();
+            }
+            _this.emit('close', e);
+        };
+        ws.onerror = function(e) {
+            if (e && e.code === 'ECONNREFUSED' && options.reconnect) {
+                _this.connect();
+            } else {
+                _this.emit('error', e);
+            }
+        };
+        this._ws = ws;
+    }
+});
+var defOpts = {
+    protocols: [],
+    reconnect: true
+};
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/Stack.d.ts

@@ -0,0 +1,13 @@
+import types = require('./types');
+
+declare class Stack {
+    size: number;
+    clear(): void;
+    push(item: any): number;
+    pop(): any;
+    peek(): any;
+    forEach(iterator: types.AnyFn, context?: any): void;
+    toArr(): any[];
+}
+
+export = Stack;

uni_modules/UniDevTools/node_modules/licia/Stack.js

@@ -0,0 +1,35 @@
+var Class = require('./Class');
+var reverse = require('./reverse');
+exports = Class({
+    initialize: function Stack() {
+        this.clear();
+    },
+    clear: function() {
+        this._items = [];
+        this.size = 0;
+    },
+    push: function(item) {
+        this._items.push(item);
+        return ++this.size;
+    },
+    pop: function() {
+        if (!this.size) return;
+        this.size--;
+        return this._items.pop();
+    },
+    peek: function() {
+        return this._items[this.size - 1];
+    },
+    forEach: function(iterator, ctx) {
+        ctx = arguments.length > 1 ? ctx : this;
+        var items = this._items;
+        for (var i = this.size - 1, j = 0; i >= 0; i--, j++) {
+            iterator.call(ctx, items[i], j, this);
+        }
+    },
+    toArr: function() {
+        return reverse(this._items);
+    }
+});
+
+module.exports = exports;

uni_modules/UniDevTools/node_modules/licia/State.d.ts

@@ -0,0 +1,9 @@
+import Emitter = require('./Emitter');
+
+declare class State extends Emitter {
+    constructor(initial: string, events: any);
+    is(state: string): boolean;
+    [event: string]: any;
+}
+
+export = State;