push the uni-demo project

uni-demo/node_modules/zrender/lib/core/BoundingRect.d.ts

@@ -0,0 +1,29 @@
+import * as matrix from './matrix';
+import { PointLike } from './Point';
+declare class BoundingRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    constructor(x: number, y: number, width: number, height: number);
+    union(other: BoundingRect): void;
+    applyTransform(m: matrix.MatrixArray): void;
+    calculateTransform(b: RectLike): matrix.MatrixArray;
+    intersect(b: RectLike, mtv?: PointLike): boolean;
+    contain(x: number, y: number): boolean;
+    clone(): BoundingRect;
+    copy(other: RectLike): void;
+    plain(): RectLike;
+    isFinite(): boolean;
+    isZero(): boolean;
+    static create(rect: RectLike): BoundingRect;
+    static copy(target: RectLike, source: RectLike): void;
+    static applyTransform(target: RectLike, source: RectLike, m: matrix.MatrixArray): void;
+}
+export declare type RectLike = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export default BoundingRect;

uni-demo/node_modules/zrender/lib/core/BoundingRect.js

@@ -0,0 +1,215 @@
+import * as matrix from './matrix.js';
+import Point from './Point.js';
+var mathMin = Math.min;
+var mathMax = Math.max;
+var lt = new Point();
+var rb = new Point();
+var lb = new Point();
+var rt = new Point();
+var minTv = new Point();
+var maxTv = new Point();
+var BoundingRect = (function () {
+    function BoundingRect(x, y, width, height) {
+        if (width < 0) {
+            x = x + width;
+            width = -width;
+        }
+        if (height < 0) {
+            y = y + height;
+            height = -height;
+        }
+        this.x = x;
+        this.y = y;
+        this.width = width;
+        this.height = height;
+    }
+    BoundingRect.prototype.union = function (other) {
+        var x = mathMin(other.x, this.x);
+        var y = mathMin(other.y, this.y);
+        if (isFinite(this.x) && isFinite(this.width)) {
+            this.width = mathMax(other.x + other.width, this.x + this.width) - x;
+        }
+        else {
+            this.width = other.width;
+        }
+        if (isFinite(this.y) && isFinite(this.height)) {
+            this.height = mathMax(other.y + other.height, this.y + this.height) - y;
+        }
+        else {
+            this.height = other.height;
+        }
+        this.x = x;
+        this.y = y;
+    };
+    BoundingRect.prototype.applyTransform = function (m) {
+        BoundingRect.applyTransform(this, this, m);
+    };
+    BoundingRect.prototype.calculateTransform = function (b) {
+        var a = this;
+        var sx = b.width / a.width;
+        var sy = b.height / a.height;
+        var m = matrix.create();
+        matrix.translate(m, m, [-a.x, -a.y]);
+        matrix.scale(m, m, [sx, sy]);
+        matrix.translate(m, m, [b.x, b.y]);
+        return m;
+    };
+    BoundingRect.prototype.intersect = function (b, mtv) {
+        if (!b) {
+            return false;
+        }
+        if (!(b instanceof BoundingRect)) {
+            b = BoundingRect.create(b);
+        }
+        var a = this;
+        var ax0 = a.x;
+        var ax1 = a.x + a.width;
+        var ay0 = a.y;
+        var ay1 = a.y + a.height;
+        var bx0 = b.x;
+        var bx1 = b.x + b.width;
+        var by0 = b.y;
+        var by1 = b.y + b.height;
+        var overlap = !(ax1 < bx0 || bx1 < ax0 || ay1 < by0 || by1 < ay0);
+        if (mtv) {
+            var dMin = Infinity;
+            var dMax = 0;
+            var d0 = Math.abs(ax1 - bx0);
+            var d1 = Math.abs(bx1 - ax0);
+            var d2 = Math.abs(ay1 - by0);
+            var d3 = Math.abs(by1 - ay0);
+            var dx = Math.min(d0, d1);
+            var dy = Math.min(d2, d3);
+            if (ax1 < bx0 || bx1 < ax0) {
+                if (dx > dMax) {
+                    dMax = dx;
+                    if (d0 < d1) {
+                        Point.set(maxTv, -d0, 0);
+                    }
+                    else {
+                        Point.set(maxTv, d1, 0);
+                    }
+                }
+            }
+            else {
+                if (dx < dMin) {
+                    dMin = dx;
+                    if (d0 < d1) {
+                        Point.set(minTv, d0, 0);
+                    }
+                    else {
+                        Point.set(minTv, -d1, 0);
+                    }
+                }
+            }
+            if (ay1 < by0 || by1 < ay0) {
+                if (dy > dMax) {
+                    dMax = dy;
+                    if (d2 < d3) {
+                        Point.set(maxTv, 0, -d2);
+                    }
+                    else {
+                        Point.set(maxTv, 0, d3);
+                    }
+                }
+            }
+            else {
+                if (dx < dMin) {
+                    dMin = dx;
+                    if (d2 < d3) {
+                        Point.set(minTv, 0, d2);
+                    }
+                    else {
+                        Point.set(minTv, 0, -d3);
+                    }
+                }
+            }
+        }
+        if (mtv) {
+            Point.copy(mtv, overlap ? minTv : maxTv);
+        }
+        return overlap;
+    };
+    BoundingRect.prototype.contain = function (x, y) {
+        var rect = this;
+        return x >= rect.x
+            && x <= (rect.x + rect.width)
+            && y >= rect.y
+            && y <= (rect.y + rect.height);
+    };
+    BoundingRect.prototype.clone = function () {
+        return new BoundingRect(this.x, this.y, this.width, this.height);
+    };
+    BoundingRect.prototype.copy = function (other) {
+        BoundingRect.copy(this, other);
+    };
+    BoundingRect.prototype.plain = function () {
+        return {
+            x: this.x,
+            y: this.y,
+            width: this.width,
+            height: this.height
+        };
+    };
+    BoundingRect.prototype.isFinite = function () {
+        return isFinite(this.x)
+            && isFinite(this.y)
+            && isFinite(this.width)
+            && isFinite(this.height);
+    };
+    BoundingRect.prototype.isZero = function () {
+        return this.width === 0 || this.height === 0;
+    };
+    BoundingRect.create = function (rect) {
+        return new BoundingRect(rect.x, rect.y, rect.width, rect.height);
+    };
+    BoundingRect.copy = function (target, source) {
+        target.x = source.x;
+        target.y = source.y;
+        target.width = source.width;
+        target.height = source.height;
+    };
+    BoundingRect.applyTransform = function (target, source, m) {
+        if (!m) {
+            if (target !== source) {
+                BoundingRect.copy(target, source);
+            }
+            return;
+        }
+        if (m[1] < 1e-5 && m[1] > -1e-5 && m[2] < 1e-5 && m[2] > -1e-5) {
+            var sx = m[0];
+            var sy = m[3];
+            var tx = m[4];
+            var ty = m[5];
+            target.x = source.x * sx + tx;
+            target.y = source.y * sy + ty;
+            target.width = source.width * sx;
+            target.height = source.height * sy;
+            if (target.width < 0) {
+                target.x += target.width;
+                target.width = -target.width;
+            }
+            if (target.height < 0) {
+                target.y += target.height;
+                target.height = -target.height;
+            }
+            return;
+        }
+        lt.x = lb.x = source.x;
+        lt.y = rt.y = source.y;
+        rb.x = rt.x = source.x + source.width;
+        rb.y = lb.y = source.y + source.height;
+        lt.transform(m);
+        rt.transform(m);
+        rb.transform(m);
+        lb.transform(m);
+        target.x = mathMin(lt.x, rb.x, lb.x, rt.x);
+        target.y = mathMin(lt.y, rb.y, lb.y, rt.y);
+        var maxX = mathMax(lt.x, rb.x, lb.x, rt.x);
+        var maxY = mathMax(lt.y, rb.y, lb.y, rt.y);
+        target.width = maxX - target.x;
+        target.height = maxY - target.y;
+    };
+    return BoundingRect;
+}());
+export default BoundingRect;

uni-demo/node_modules/zrender/lib/core/Eventful.d.ts

@@ -0,0 +1,23 @@
+import { Dictionary, WithThisType } from './types';
+export declare type EventCallbackSingleParam<EvtParam = any> = EvtParam extends any ? (params: EvtParam) => boolean | void : never;
+export declare type EventCallback<EvtParams = any[]> = EvtParams extends any[] ? (...args: EvtParams) => boolean | void : never;
+export declare type EventQuery = string | Object;
+declare type CbThis<Ctx, Impl> = unknown extends Ctx ? Impl : Ctx;
+declare type DefaultEventDefinition = Dictionary<EventCallback<any[]>>;
+export interface EventProcessor<EvtDef = DefaultEventDefinition> {
+    normalizeQuery?: (query: EventQuery) => EventQuery;
+    filter?: (eventType: keyof EvtDef, query: EventQuery) => boolean;
+    afterTrigger?: (eventType: keyof EvtDef) => void;
+}
+export default class Eventful<EvtDef extends DefaultEventDefinition = DefaultEventDefinition> {
+    private _$handlers;
+    protected _$eventProcessor: EventProcessor<EvtDef>;
+    constructor(eventProcessors?: EventProcessor<EvtDef>);
+    on<Ctx, EvtNm extends keyof EvtDef>(event: EvtNm, handler: WithThisType<EvtDef[EvtNm], CbThis<Ctx, this>>, context?: Ctx): this;
+    on<Ctx, EvtNm extends keyof EvtDef>(event: EvtNm, query: EventQuery, handler: WithThisType<EvtDef[EvtNm], CbThis<Ctx, this>>, context?: Ctx): this;
+    isSilent(eventName: keyof EvtDef): boolean;
+    off(eventType?: keyof EvtDef, handler?: Function): this;
+    trigger<EvtNm extends keyof EvtDef>(eventType: EvtNm, ...args: Parameters<EvtDef[EvtNm]>): this;
+    triggerWithContext(type: keyof EvtDef, ...args: any[]): this;
+}
+export {};

uni-demo/node_modules/zrender/lib/core/Eventful.js

@@ -0,0 +1,162 @@
+var Eventful = (function () {
+    function Eventful(eventProcessors) {
+        if (eventProcessors) {
+            this._$eventProcessor = eventProcessors;
+        }
+    }
+    Eventful.prototype.on = function (event, query, handler, context) {
+        if (!this._$handlers) {
+            this._$handlers = {};
+        }
+        var _h = this._$handlers;
+        if (typeof query === 'function') {
+            context = handler;
+            handler = query;
+            query = null;
+        }
+        if (!handler || !event) {
+            return this;
+        }
+        var eventProcessor = this._$eventProcessor;
+        if (query != null && eventProcessor && eventProcessor.normalizeQuery) {
+            query = eventProcessor.normalizeQuery(query);
+        }
+        if (!_h[event]) {
+            _h[event] = [];
+        }
+        for (var i = 0; i < _h[event].length; i++) {
+            if (_h[event][i].h === handler) {
+                return this;
+            }
+        }
+        var wrap = {
+            h: handler,
+            query: query,
+            ctx: (context || this),
+            callAtLast: handler.zrEventfulCallAtLast
+        };
+        var lastIndex = _h[event].length - 1;
+        var lastWrap = _h[event][lastIndex];
+        (lastWrap && lastWrap.callAtLast)
+            ? _h[event].splice(lastIndex, 0, wrap)
+            : _h[event].push(wrap);
+        return this;
+    };
+    Eventful.prototype.isSilent = function (eventName) {
+        var _h = this._$handlers;
+        return !_h || !_h[eventName] || !_h[eventName].length;
+    };
+    Eventful.prototype.off = function (eventType, handler) {
+        var _h = this._$handlers;
+        if (!_h) {
+            return this;
+        }
+        if (!eventType) {
+            this._$handlers = {};
+            return this;
+        }
+        if (handler) {
+            if (_h[eventType]) {
+                var newList = [];
+                for (var i = 0, l = _h[eventType].length; i < l; i++) {
+                    if (_h[eventType][i].h !== handler) {
+                        newList.push(_h[eventType][i]);
+                    }
+                }
+                _h[eventType] = newList;
+            }
+            if (_h[eventType] && _h[eventType].length === 0) {
+                delete _h[eventType];
+            }
+        }
+        else {
+            delete _h[eventType];
+        }
+        return this;
+    };
+    Eventful.prototype.trigger = function (eventType) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        if (!this._$handlers) {
+            return this;
+        }
+        var _h = this._$handlers[eventType];
+        var eventProcessor = this._$eventProcessor;
+        if (_h) {
+            var argLen = args.length;
+            var len = _h.length;
+            for (var i = 0; i < len; i++) {
+                var hItem = _h[i];
+                if (eventProcessor
+                    && eventProcessor.filter
+                    && hItem.query != null
+                    && !eventProcessor.filter(eventType, hItem.query)) {
+                    continue;
+                }
+                switch (argLen) {
+                    case 0:
+                        hItem.h.call(hItem.ctx);
+                        break;
+                    case 1:
+                        hItem.h.call(hItem.ctx, args[0]);
+                        break;
+                    case 2:
+                        hItem.h.call(hItem.ctx, args[0], args[1]);
+                        break;
+                    default:
+                        hItem.h.apply(hItem.ctx, args);
+                        break;
+                }
+            }
+        }
+        eventProcessor && eventProcessor.afterTrigger
+            && eventProcessor.afterTrigger(eventType);
+        return this;
+    };
+    Eventful.prototype.triggerWithContext = function (type) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        if (!this._$handlers) {
+            return this;
+        }
+        var _h = this._$handlers[type];
+        var eventProcessor = this._$eventProcessor;
+        if (_h) {
+            var argLen = args.length;
+            var ctx = args[argLen - 1];
+            var len = _h.length;
+            for (var i = 0; i < len; i++) {
+                var hItem = _h[i];
+                if (eventProcessor
+                    && eventProcessor.filter
+                    && hItem.query != null
+                    && !eventProcessor.filter(type, hItem.query)) {
+                    continue;
+                }
+                switch (argLen) {
+                    case 0:
+                        hItem.h.call(ctx);
+                        break;
+                    case 1:
+                        hItem.h.call(ctx, args[0]);
+                        break;
+                    case 2:
+                        hItem.h.call(ctx, args[0], args[1]);
+                        break;
+                    default:
+                        hItem.h.apply(ctx, args.slice(1, argLen - 1));
+                        break;
+                }
+            }
+        }
+        eventProcessor && eventProcessor.afterTrigger
+            && eventProcessor.afterTrigger(type);
+        return this;
+    };
+    return Eventful;
+}());
+export default Eventful;

uni-demo/node_modules/zrender/lib/core/GestureMgr.d.ts

@@ -0,0 +1,18 @@
+import { ZRRawTouchEvent } from './types';
+import Displayable from '../graphic/Displayable';
+export declare class GestureMgr {
+    private _track;
+    constructor();
+    recognize(event: ZRRawTouchEvent, target: Displayable, root: HTMLElement): {
+        type: string;
+        target: Displayable<import("../graphic/Displayable").DisplayableProps>;
+        event: ZRRawTouchEvent;
+    };
+    clear(): this;
+    _doTrack(event: ZRRawTouchEvent, target: Displayable, root: HTMLElement): void;
+    _recognize(event: ZRRawTouchEvent): {
+        type: string;
+        target: Displayable<import("../graphic/Displayable").DisplayableProps>;
+        event: ZRRawTouchEvent;
+    };
+}

uni-demo/node_modules/zrender/lib/core/GestureMgr.js

@@ -0,0 +1,82 @@
+import * as eventUtil from './event.js';
+var GestureMgr = (function () {
+    function GestureMgr() {
+        this._track = [];
+    }
+    GestureMgr.prototype.recognize = function (event, target, root) {
+        this._doTrack(event, target, root);
+        return this._recognize(event);
+    };
+    GestureMgr.prototype.clear = function () {
+        this._track.length = 0;
+        return this;
+    };
+    GestureMgr.prototype._doTrack = function (event, target, root) {
+        var touches = event.touches;
+        if (!touches) {
+            return;
+        }
+        var trackItem = {
+            points: [],
+            touches: [],
+            target: target,
+            event: event
+        };
+        for (var i = 0, len = touches.length; i < len; i++) {
+            var touch = touches[i];
+            var pos = eventUtil.clientToLocal(root, touch, {});
+            trackItem.points.push([pos.zrX, pos.zrY]);
+            trackItem.touches.push(touch);
+        }
+        this._track.push(trackItem);
+    };
+    GestureMgr.prototype._recognize = function (event) {
+        for (var eventName in recognizers) {
+            if (recognizers.hasOwnProperty(eventName)) {
+                var gestureInfo = recognizers[eventName](this._track, event);
+                if (gestureInfo) {
+                    return gestureInfo;
+                }
+            }
+        }
+    };
+    return GestureMgr;
+}());
+export { GestureMgr };
+function dist(pointPair) {
+    var dx = pointPair[1][0] - pointPair[0][0];
+    var dy = pointPair[1][1] - pointPair[0][1];
+    return Math.sqrt(dx * dx + dy * dy);
+}
+function center(pointPair) {
+    return [
+        (pointPair[0][0] + pointPair[1][0]) / 2,
+        (pointPair[0][1] + pointPair[1][1]) / 2
+    ];
+}
+var recognizers = {
+    pinch: function (tracks, event) {
+        var trackLen = tracks.length;
+        if (!trackLen) {
+            return;
+        }
+        var pinchEnd = (tracks[trackLen - 1] || {}).points;
+        var pinchPre = (tracks[trackLen - 2] || {}).points || pinchEnd;
+        if (pinchPre
+            && pinchPre.length > 1
+            && pinchEnd
+            && pinchEnd.length > 1) {
+            var pinchScale = dist(pinchEnd) / dist(pinchPre);
+            !isFinite(pinchScale) && (pinchScale = 1);
+            event.pinchScale = pinchScale;
+            var pinchCenter = center(pinchEnd);
+            event.pinchX = pinchCenter[0];
+            event.pinchY = pinchCenter[1];
+            return {
+                type: 'pinch',
+                target: tracks[0].target,
+                event: event
+            };
+        }
+    }
+};

uni-demo/node_modules/zrender/lib/core/LRU.d.ts

@@ -0,0 +1,28 @@
+export declare class Entry<T> {
+    value: T;
+    key: string | number;
+    next: Entry<T>;
+    prev: Entry<T>;
+    constructor(val: T);
+}
+export declare class LinkedList<T> {
+    head: Entry<T>;
+    tail: Entry<T>;
+    private _len;
+    insert(val: T): Entry<T>;
+    insertEntry(entry: Entry<T>): void;
+    remove(entry: Entry<T>): void;
+    len(): number;
+    clear(): void;
+}
+export default class LRU<T> {
+    private _list;
+    private _maxSize;
+    private _lastRemovedEntry;
+    private _map;
+    constructor(maxSize: number);
+    put(key: string | number, value: T): T;
+    get(key: string | number): T;
+    clear(): void;
+    len(): number;
+}

uni-demo/node_modules/zrender/lib/core/LRU.js

@@ -0,0 +1,110 @@
+var Entry = (function () {
+    function Entry(val) {
+        this.value = val;
+    }
+    return Entry;
+}());
+export { Entry };
+var LinkedList = (function () {
+    function LinkedList() {
+        this._len = 0;
+    }
+    LinkedList.prototype.insert = function (val) {
+        var entry = new Entry(val);
+        this.insertEntry(entry);
+        return entry;
+    };
+    LinkedList.prototype.insertEntry = function (entry) {
+        if (!this.head) {
+            this.head = this.tail = entry;
+        }
+        else {
+            this.tail.next = entry;
+            entry.prev = this.tail;
+            entry.next = null;
+            this.tail = entry;
+        }
+        this._len++;
+    };
+    LinkedList.prototype.remove = function (entry) {
+        var prev = entry.prev;
+        var next = entry.next;
+        if (prev) {
+            prev.next = next;
+        }
+        else {
+            this.head = next;
+        }
+        if (next) {
+            next.prev = prev;
+        }
+        else {
+            this.tail = prev;
+        }
+        entry.next = entry.prev = null;
+        this._len--;
+    };
+    LinkedList.prototype.len = function () {
+        return this._len;
+    };
+    LinkedList.prototype.clear = function () {
+        this.head = this.tail = null;
+        this._len = 0;
+    };
+    return LinkedList;
+}());
+export { LinkedList };
+var LRU = (function () {
+    function LRU(maxSize) {
+        this._list = new LinkedList();
+        this._maxSize = 10;
+        this._map = {};
+        this._maxSize = maxSize;
+    }
+    LRU.prototype.put = function (key, value) {
+        var list = this._list;
+        var map = this._map;
+        var removed = null;
+        if (map[key] == null) {
+            var len = list.len();
+            var entry = this._lastRemovedEntry;
+            if (len >= this._maxSize && len > 0) {
+                var leastUsedEntry = list.head;
+                list.remove(leastUsedEntry);
+                delete map[leastUsedEntry.key];
+                removed = leastUsedEntry.value;
+                this._lastRemovedEntry = leastUsedEntry;
+            }
+            if (entry) {
+                entry.value = value;
+            }
+            else {
+                entry = new Entry(value);
+            }
+            entry.key = key;
+            list.insertEntry(entry);
+            map[key] = entry;
+        }
+        return removed;
+    };
+    LRU.prototype.get = function (key) {
+        var entry = this._map[key];
+        var list = this._list;
+        if (entry != null) {
+            if (entry !== list.tail) {
+                list.remove(entry);
+                list.insertEntry(entry);
+            }
+            return entry.value;
+        }
+    };
+    LRU.prototype.clear = function () {
+        this._list.clear();
+        this._map = {};
+    };
+    LRU.prototype.len = function () {
+        return this._list.len();
+    };
+    return LRU;
+}());
+export default LRU;

uni-demo/node_modules/zrender/lib/core/OrientedBoundingRect.d.ts

@@ -0,0 +1,14 @@
+import { PointLike } from './Point';
+import BoundingRect from './BoundingRect';
+import { MatrixArray } from './matrix';
+declare class OrientedBoundingRect {
+    private _corners;
+    private _axes;
+    private _origin;
+    constructor(rect?: BoundingRect, transform?: MatrixArray);
+    fromBoundingRect(rect: BoundingRect, transform?: MatrixArray): void;
+    intersect(other: OrientedBoundingRect, mtv?: PointLike): boolean;
+    private _intersectCheckOneSide;
+    private _getProjMinMaxOnAxis;
+}
+export default OrientedBoundingRect;

uni-demo/node_modules/zrender/lib/core/OrientedBoundingRect.js

@@ -0,0 +1,120 @@
+import Point from './Point.js';
+var extent = [0, 0];
+var extent2 = [0, 0];
+var minTv = new Point();
+var maxTv = new Point();
+var OrientedBoundingRect = (function () {
+    function OrientedBoundingRect(rect, transform) {
+        this._corners = [];
+        this._axes = [];
+        this._origin = [0, 0];
+        for (var i = 0; i < 4; i++) {
+            this._corners[i] = new Point();
+        }
+        for (var i = 0; i < 2; i++) {
+            this._axes[i] = new Point();
+        }
+        if (rect) {
+            this.fromBoundingRect(rect, transform);
+        }
+    }
+    OrientedBoundingRect.prototype.fromBoundingRect = function (rect, transform) {
+        var corners = this._corners;
+        var axes = this._axes;
+        var x = rect.x;
+        var y = rect.y;
+        var x2 = x + rect.width;
+        var y2 = y + rect.height;
+        corners[0].set(x, y);
+        corners[1].set(x2, y);
+        corners[2].set(x2, y2);
+        corners[3].set(x, y2);
+        if (transform) {
+            for (var i = 0; i < 4; i++) {
+                corners[i].transform(transform);
+            }
+        }
+        Point.sub(axes[0], corners[1], corners[0]);
+        Point.sub(axes[1], corners[3], corners[0]);
+        axes[0].normalize();
+        axes[1].normalize();
+        for (var i = 0; i < 2; i++) {
+            this._origin[i] = axes[i].dot(corners[0]);
+        }
+    };
+    OrientedBoundingRect.prototype.intersect = function (other, mtv) {
+        var overlapped = true;
+        var noMtv = !mtv;
+        minTv.set(Infinity, Infinity);
+        maxTv.set(0, 0);
+        if (!this._intersectCheckOneSide(this, other, minTv, maxTv, noMtv, 1)) {
+            overlapped = false;
+            if (noMtv) {
+                return overlapped;
+            }
+        }
+        if (!this._intersectCheckOneSide(other, this, minTv, maxTv, noMtv, -1)) {
+            overlapped = false;
+            if (noMtv) {
+                return overlapped;
+            }
+        }
+        if (!noMtv) {
+            Point.copy(mtv, overlapped ? minTv : maxTv);
+        }
+        return overlapped;
+    };
+    OrientedBoundingRect.prototype._intersectCheckOneSide = function (self, other, minTv, maxTv, noMtv, inverse) {
+        var overlapped = true;
+        for (var i = 0; i < 2; i++) {
+            var axis = this._axes[i];
+            this._getProjMinMaxOnAxis(i, self._corners, extent);
+            this._getProjMinMaxOnAxis(i, other._corners, extent2);
+            if (extent[1] < extent2[0] || extent[0] > extent2[1]) {
+                overlapped = false;
+                if (noMtv) {
+                    return overlapped;
+                }
+                var dist0 = Math.abs(extent2[0] - extent[1]);
+                var dist1 = Math.abs(extent[0] - extent2[1]);
+                if (Math.min(dist0, dist1) > maxTv.len()) {
+                    if (dist0 < dist1) {
+                        Point.scale(maxTv, axis, -dist0 * inverse);
+                    }
+                    else {
+                        Point.scale(maxTv, axis, dist1 * inverse);
+                    }
+                }
+            }
+            else if (minTv) {
+                var dist0 = Math.abs(extent2[0] - extent[1]);
+                var dist1 = Math.abs(extent[0] - extent2[1]);
+                if (Math.min(dist0, dist1) < minTv.len()) {
+                    if (dist0 < dist1) {
+                        Point.scale(minTv, axis, dist0 * inverse);
+                    }
+                    else {
+                        Point.scale(minTv, axis, -dist1 * inverse);
+                    }
+                }
+            }
+        }
+        return overlapped;
+    };
+    OrientedBoundingRect.prototype._getProjMinMaxOnAxis = function (dim, corners, out) {
+        var axis = this._axes[dim];
+        var origin = this._origin;
+        var proj = corners[0].dot(axis) + origin[dim];
+        var min = proj;
+        var max = proj;
+        for (var i = 1; i < corners.length; i++) {
+            var proj_1 = corners[i].dot(axis) + origin[dim];
+            min = Math.min(proj_1, min);
+            max = Math.max(proj_1, max);
+        }
+        out[0] = min;
+        out[1] = max;
+    };
+    return OrientedBoundingRect;
+}());
+export default OrientedBoundingRect;

uni-demo/node_modules/zrender/lib/core/PathProxy.d.ts

@@ -0,0 +1,75 @@
+import BoundingRect from './BoundingRect';
+interface ExtendedCanvasRenderingContext2D extends CanvasRenderingContext2D {
+    dpr?: number;
+}
+export declare function normalizeArcAngles(angles: number[], anticlockwise: boolean): void;
+export default class PathProxy {
+    dpr: number;
+    data: number[] | Float32Array;
+    private _version;
+    private _saveData;
+    private _pendingPtX;
+    private _pendingPtY;
+    private _pendingPtDist;
+    private _ctx;
+    private _xi;
+    private _yi;
+    private _x0;
+    private _y0;
+    private _len;
+    private _pathSegLen;
+    private _pathLen;
+    private _ux;
+    private _uy;
+    static CMD: {
+        M: number;
+        L: number;
+        C: number;
+        Q: number;
+        A: number;
+        Z: number;
+        R: number;
+    };
+    constructor(notSaveData?: boolean);
+    increaseVersion(): void;
+    getVersion(): number;
+    setScale(sx: number, sy: number, segmentIgnoreThreshold?: number): void;
+    setDPR(dpr: number): void;
+    setContext(ctx: ExtendedCanvasRenderingContext2D): void;
+    getContext(): ExtendedCanvasRenderingContext2D;
+    beginPath(): this;
+    reset(): void;
+    moveTo(x: number, y: number): this;
+    lineTo(x: number, y: number): this;
+    bezierCurveTo(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): this;
+    quadraticCurveTo(x1: number, y1: number, x2: number, y2: number): this;
+    arc(cx: number, cy: number, r: number, startAngle: number, endAngle: number, anticlockwise?: boolean): this;
+    arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): this;
+    rect(x: number, y: number, w: number, h: number): this;
+    closePath(): this;
+    fill(ctx: CanvasRenderingContext2D): void;
+    stroke(ctx: CanvasRenderingContext2D): void;
+    len(): number;
+    setData(data: Float32Array | number[]): void;
+    appendPath(path: PathProxy | PathProxy[]): void;
+    addData(cmd: number, a?: number, b?: number, c?: number, d?: number, e?: number, f?: number, g?: number, h?: number): void;
+    private _drawPendingPt;
+    private _expandData;
+    toStatic(): void;
+    getBoundingRect(): BoundingRect;
+    private _calculateLength;
+    rebuildPath(ctx: PathRebuilder, percent: number): void;
+    clone(): PathProxy;
+    private static initDefaultProps;
+}
+export interface PathRebuilder {
+    moveTo(x: number, y: number): void;
+    lineTo(x: number, y: number): void;
+    bezierCurveTo(x: number, y: number, x2: number, y2: number, x3: number, y3: number): void;
+    quadraticCurveTo(x: number, y: number, x2: number, y2: number): void;
+    arc(cx: number, cy: number, r: number, startAngle: number, endAngle: number, anticlockwise: boolean): void;
+    ellipse(cx: number, cy: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, anticlockwise: boolean): void;
+    rect(x: number, y: number, width: number, height: number): void;
+    closePath(): void;
+}
+export {};

uni-demo/node_modules/zrender/lib/core/PathProxy.js

@@ -0,0 +1,698 @@
+import * as vec2 from './vector.js';
+import BoundingRect from './BoundingRect.js';
+import { devicePixelRatio as dpr } from '../config.js';
+import { fromLine, fromCubic, fromQuadratic, fromArc } from './bbox.js';
+import { cubicLength, cubicSubdivide, quadraticLength, quadraticSubdivide } from './curve.js';
+var CMD = {
+    M: 1,
+    L: 2,
+    C: 3,
+    Q: 4,
+    A: 5,
+    Z: 6,
+    R: 7
+};
+var tmpOutX = [];
+var tmpOutY = [];
+var min = [];
+var max = [];
+var min2 = [];
+var max2 = [];
+var mathMin = Math.min;
+var mathMax = Math.max;
+var mathCos = Math.cos;
+var mathSin = Math.sin;
+var mathAbs = Math.abs;
+var PI = Math.PI;
+var PI2 = PI * 2;
+var hasTypedArray = typeof Float32Array !== 'undefined';
+var tmpAngles = [];
+function modPI2(radian) {
+    var n = Math.round(radian / PI * 1e8) / 1e8;
+    return (n % 2) * PI;
+}
+export function normalizeArcAngles(angles, anticlockwise) {
+    var newStartAngle = modPI2(angles[0]);
+    if (newStartAngle < 0) {
+        newStartAngle += PI2;
+    }
+    var delta = newStartAngle - angles[0];
+    var newEndAngle = angles[1];
+    newEndAngle += delta;
+    if (!anticlockwise && newEndAngle - newStartAngle >= PI2) {
+        newEndAngle = newStartAngle + PI2;
+    }
+    else if (anticlockwise && newStartAngle - newEndAngle >= PI2) {
+        newEndAngle = newStartAngle - PI2;
+    }
+    else if (!anticlockwise && newStartAngle > newEndAngle) {
+        newEndAngle = newStartAngle + (PI2 - modPI2(newStartAngle - newEndAngle));
+    }
+    else if (anticlockwise && newStartAngle < newEndAngle) {
+        newEndAngle = newStartAngle - (PI2 - modPI2(newEndAngle - newStartAngle));
+    }
+    angles[0] = newStartAngle;
+    angles[1] = newEndAngle;
+}
+var PathProxy = (function () {
+    function PathProxy(notSaveData) {
+        this.dpr = 1;
+        this._xi = 0;
+        this._yi = 0;
+        this._x0 = 0;
+        this._y0 = 0;
+        this._len = 0;
+        if (notSaveData) {
+            this._saveData = false;
+        }
+        if (this._saveData) {
+            this.data = [];
+        }
+    }
+    PathProxy.prototype.increaseVersion = function () {
+        this._version++;
+    };
+    PathProxy.prototype.getVersion = function () {
+        return this._version;
+    };
+    PathProxy.prototype.setScale = function (sx, sy, segmentIgnoreThreshold) {
+        segmentIgnoreThreshold = segmentIgnoreThreshold || 0;
+        if (segmentIgnoreThreshold > 0) {
+            this._ux = mathAbs(segmentIgnoreThreshold / dpr / sx) || 0;
+            this._uy = mathAbs(segmentIgnoreThreshold / dpr / sy) || 0;
+        }
+    };
+    PathProxy.prototype.setDPR = function (dpr) {
+        this.dpr = dpr;
+    };
+    PathProxy.prototype.setContext = function (ctx) {
+        this._ctx = ctx;
+    };
+    PathProxy.prototype.getContext = function () {
+        return this._ctx;
+    };
+    PathProxy.prototype.beginPath = function () {
+        this._ctx && this._ctx.beginPath();
+        this.reset();
+        return this;
+    };
+    PathProxy.prototype.reset = function () {
+        if (this._saveData) {
+            this._len = 0;
+        }
+        if (this._pathSegLen) {
+            this._pathSegLen = null;
+            this._pathLen = 0;
+        }
+        this._version++;
+    };
+    PathProxy.prototype.moveTo = function (x, y) {
+        this._drawPendingPt();
+        this.addData(CMD.M, x, y);
+        this._ctx && this._ctx.moveTo(x, y);
+        this._x0 = x;
+        this._y0 = y;
+        this._xi = x;
+        this._yi = y;
+        return this;
+    };
+    PathProxy.prototype.lineTo = function (x, y) {
+        var dx = mathAbs(x - this._xi);
+        var dy = mathAbs(y - this._yi);
+        var exceedUnit = dx > this._ux || dy > this._uy;
+        this.addData(CMD.L, x, y);
+        if (this._ctx && exceedUnit) {
+            this._ctx.lineTo(x, y);
+        }
+        if (exceedUnit) {
+            this._xi = x;
+            this._yi = y;
+            this._pendingPtDist = 0;
+        }
+        else {
+            var d2 = dx * dx + dy * dy;
+            if (d2 > this._pendingPtDist) {
+                this._pendingPtX = x;
+                this._pendingPtY = y;
+                this._pendingPtDist = d2;
+            }
+        }
+        return this;
+    };
+    PathProxy.prototype.bezierCurveTo = function (x1, y1, x2, y2, x3, y3) {
+        this._drawPendingPt();
+        this.addData(CMD.C, x1, y1, x2, y2, x3, y3);
+        if (this._ctx) {
+            this._ctx.bezierCurveTo(x1, y1, x2, y2, x3, y3);
+        }
+        this._xi = x3;
+        this._yi = y3;
+        return this;
+    };
+    PathProxy.prototype.quadraticCurveTo = function (x1, y1, x2, y2) {
+        this._drawPendingPt();
+        this.addData(CMD.Q, x1, y1, x2, y2);
+        if (this._ctx) {
+            this._ctx.quadraticCurveTo(x1, y1, x2, y2);
+        }
+        this._xi = x2;
+        this._yi = y2;
+        return this;
+    };
+    PathProxy.prototype.arc = function (cx, cy, r, startAngle, endAngle, anticlockwise) {
+        this._drawPendingPt();
+        tmpAngles[0] = startAngle;
+        tmpAngles[1] = endAngle;
+        normalizeArcAngles(tmpAngles, anticlockwise);
+        startAngle = tmpAngles[0];
+        endAngle = tmpAngles[1];
+        var delta = endAngle - startAngle;
+        this.addData(CMD.A, cx, cy, r, r, startAngle, delta, 0, anticlockwise ? 0 : 1);
+        this._ctx && this._ctx.arc(cx, cy, r, startAngle, endAngle, anticlockwise);
+        this._xi = mathCos(endAngle) * r + cx;
+        this._yi = mathSin(endAngle) * r + cy;
+        return this;
+    };
+    PathProxy.prototype.arcTo = function (x1, y1, x2, y2, radius) {
+        this._drawPendingPt();
+        if (this._ctx) {
+            this._ctx.arcTo(x1, y1, x2, y2, radius);
+        }
+        return this;
+    };
+    PathProxy.prototype.rect = function (x, y, w, h) {
+        this._drawPendingPt();
+        this._ctx && this._ctx.rect(x, y, w, h);
+        this.addData(CMD.R, x, y, w, h);
+        return this;
+    };
+    PathProxy.prototype.closePath = function () {
+        this._drawPendingPt();
+        this.addData(CMD.Z);
+        var ctx = this._ctx;
+        var x0 = this._x0;
+        var y0 = this._y0;
+        if (ctx) {
+            ctx.closePath();
+        }
+        this._xi = x0;
+        this._yi = y0;
+        return this;
+    };
+    PathProxy.prototype.fill = function (ctx) {
+        ctx && ctx.fill();
+        this.toStatic();
+    };
+    PathProxy.prototype.stroke = function (ctx) {
+        ctx && ctx.stroke();
+        this.toStatic();
+    };
+    PathProxy.prototype.len = function () {
+        return this._len;
+    };
+    PathProxy.prototype.setData = function (data) {
+        var len = data.length;
+        if (!(this.data && this.data.length === len) && hasTypedArray) {
+            this.data = new Float32Array(len);
+        }
+        for (var i = 0; i < len; i++) {
+            this.data[i] = data[i];
+        }
+        this._len = len;
+    };
+    PathProxy.prototype.appendPath = function (path) {
+        if (!(path instanceof Array)) {
+            path = [path];
+        }
+        var len = path.length;
+        var appendSize = 0;
+        var offset = this._len;
+        for (var i = 0; i < len; i++) {
+            appendSize += path[i].len();
+        }
+        if (hasTypedArray && (this.data instanceof Float32Array)) {
+            this.data = new Float32Array(offset + appendSize);
+        }
+        for (var i = 0; i < len; i++) {
+            var appendPathData = path[i].data;
+            for (var k = 0; k < appendPathData.length; k++) {
+                this.data[offset++] = appendPathData[k];
+            }
+        }
+        this._len = offset;
+    };
+    PathProxy.prototype.addData = function (cmd, a, b, c, d, e, f, g, h) {
+        if (!this._saveData) {
+            return;
+        }
+        var data = this.data;
+        if (this._len + arguments.length > data.length) {
+            this._expandData();
+            data = this.data;
+        }
+        for (var i = 0; i < arguments.length; i++) {
+            data[this._len++] = arguments[i];
+        }
+    };
+    PathProxy.prototype._drawPendingPt = function () {
+        if (this._pendingPtDist > 0) {
+            this._ctx && this._ctx.lineTo(this._pendingPtX, this._pendingPtY);
+            this._pendingPtDist = 0;
+        }
+    };
+    PathProxy.prototype._expandData = function () {
+        if (!(this.data instanceof Array)) {
+            var newData = [];
+            for (var i = 0; i < this._len; i++) {
+                newData[i] = this.data[i];
+            }
+            this.data = newData;
+        }
+    };
+    PathProxy.prototype.toStatic = function () {
+        if (!this._saveData) {
+            return;
+        }
+        this._drawPendingPt();
+        var data = this.data;
+        if (data instanceof Array) {
+            data.length = this._len;
+            if (hasTypedArray && this._len > 11) {
+                this.data = new Float32Array(data);
+            }
+        }
+    };
+    PathProxy.prototype.getBoundingRect = function () {
+        min[0] = min[1] = min2[0] = min2[1] = Number.MAX_VALUE;
+        max[0] = max[1] = max2[0] = max2[1] = -Number.MAX_VALUE;
+        var data = this.data;
+        var xi = 0;
+        var yi = 0;
+        var x0 = 0;
+        var y0 = 0;
+        var i;
+        for (i = 0; i < this._len;) {
+            var cmd = data[i++];
+            var isFirst = i === 1;
+            if (isFirst) {
+                xi = data[i];
+                yi = data[i + 1];
+                x0 = xi;
+                y0 = yi;
+            }
+            switch (cmd) {
+                case CMD.M:
+                    xi = x0 = data[i++];
+                    yi = y0 = data[i++];
+                    min2[0] = x0;
+                    min2[1] = y0;
+                    max2[0] = x0;
+                    max2[1] = y0;
+                    break;
+                case CMD.L:
+                    fromLine(xi, yi, data[i], data[i + 1], min2, max2);
+                    xi = data[i++];
+                    yi = data[i++];
+                    break;
+                case CMD.C:
+                    fromCubic(xi, yi, data[i++], data[i++], data[i++], data[i++], data[i], data[i + 1], min2, max2);
+                    xi = data[i++];
+                    yi = data[i++];
+                    break;
+                case CMD.Q:
+                    fromQuadratic(xi, yi, data[i++], data[i++], data[i], data[i + 1], min2, max2);
+                    xi = data[i++];
+                    yi = data[i++];
+                    break;
+                case CMD.A:
+                    var cx = data[i++];
+                    var cy = data[i++];
+                    var rx = data[i++];
+                    var ry = data[i++];
+                    var startAngle = data[i++];
+                    var endAngle = data[i++] + startAngle;
+                    i += 1;
+                    var anticlockwise = !data[i++];
+                    if (isFirst) {
+                        x0 = mathCos(startAngle) * rx + cx;
+                        y0 = mathSin(startAngle) * ry + cy;
+                    }
+                    fromArc(cx, cy, rx, ry, startAngle, endAngle, anticlockwise, min2, max2);
+                    xi = mathCos(endAngle) * rx + cx;
+                    yi = mathSin(endAngle) * ry + cy;
+                    break;
+                case CMD.R:
+                    x0 = xi = data[i++];
+                    y0 = yi = data[i++];
+                    var width = data[i++];
+                    var height = data[i++];
+                    fromLine(x0, y0, x0 + width, y0 + height, min2, max2);
+                    break;
+                case CMD.Z:
+                    xi = x0;
+                    yi = y0;
+                    break;
+            }
+            vec2.min(min, min, min2);
+            vec2.max(max, max, max2);
+        }
+        if (i === 0) {
+            min[0] = min[1] = max[0] = max[1] = 0;
+        }
+        return new BoundingRect(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+    };
+    PathProxy.prototype._calculateLength = function () {
+        var data = this.data;
+        var len = this._len;
+        var ux = this._ux;
+        var uy = this._uy;
+        var xi = 0;
+        var yi = 0;
+        var x0 = 0;
+        var y0 = 0;
+        if (!this._pathSegLen) {
+            this._pathSegLen = [];
+        }
+        var pathSegLen = this._pathSegLen;
+        var pathTotalLen = 0;
+        var segCount = 0;
+        for (var i = 0; i < len;) {
+            var cmd = data[i++];
+            var isFirst = i === 1;
+            if (isFirst) {
+                xi = data[i];
+                yi = data[i + 1];
+                x0 = xi;
+                y0 = yi;
+            }
+            var l = -1;
+            switch (cmd) {
+                case CMD.M:
+                    xi = x0 = data[i++];
+                    yi = y0 = data[i++];
+                    break;
+                case CMD.L: {
+                    var x2 = data[i++];
+                    var y2 = data[i++];
+                    var dx = x2 - xi;
+                    var dy = y2 - yi;
+                    if (mathAbs(dx) > ux || mathAbs(dy) > uy || i === len - 1) {
+                        l = Math.sqrt(dx * dx + dy * dy);
+                        xi = x2;
+                        yi = y2;
+                    }
+                    break;
+                }
+                case CMD.C: {
+                    var x1 = data[i++];
+                    var y1 = data[i++];
+                    var x2 = data[i++];
+                    var y2 = data[i++];
+                    var x3 = data[i++];
+                    var y3 = data[i++];
+                    l = cubicLength(xi, yi, x1, y1, x2, y2, x3, y3, 10);
+                    xi = x3;
+                    yi = y3;
+                    break;
+                }
+                case CMD.Q: {
+                    var x1 = data[i++];
+                    var y1 = data[i++];
+                    var x2 = data[i++];
+                    var y2 = data[i++];
+                    l = quadraticLength(xi, yi, x1, y1, x2, y2, 10);
+                    xi = x2;
+                    yi = y2;
+                    break;
+                }
+                case CMD.A:
+                    var cx = data[i++];
+                    var cy = data[i++];
+                    var rx = data[i++];
+                    var ry = data[i++];
+                    var startAngle = data[i++];
+                    var delta = data[i++];
+                    var endAngle = delta + startAngle;
+                    i += 1;
+                    var anticlockwise = !data[i++];
+                    if (isFirst) {
+                        x0 = mathCos(startAngle) * rx + cx;
+                        y0 = mathSin(startAngle) * ry + cy;
+                    }
+                    l = mathMax(rx, ry) * mathMin(PI2, Math.abs(delta));
+                    xi = mathCos(endAngle) * rx + cx;
+                    yi = mathSin(endAngle) * ry + cy;
+                    break;
+                case CMD.R: {
+                    x0 = xi = data[i++];
+                    y0 = yi = data[i++];
+                    var width = data[i++];
+                    var height = data[i++];
+                    l = width * 2 + height * 2;
+                    break;
+                }
+                case CMD.Z: {
+                    var dx = x0 - xi;
+                    var dy = y0 - yi;
+                    l = Math.sqrt(dx * dx + dy * dy);
+                    xi = x0;
+                    yi = y0;
+                    break;
+                }
+            }
+            if (l >= 0) {
+                pathSegLen[segCount++] = l;
+                pathTotalLen += l;
+            }
+        }
+        this._pathLen = pathTotalLen;
+        return pathTotalLen;
+    };
+    PathProxy.prototype.rebuildPath = function (ctx, percent) {
+        var d = this.data;
+        var ux = this._ux;
+        var uy = this._uy;
+        var len = this._len;
+        var x0;
+        var y0;
+        var xi;
+        var yi;
+        var x;
+        var y;
+        var drawPart = percent < 1;
+        var pathSegLen;
+        var pathTotalLen;
+        var accumLength = 0;
+        var segCount = 0;
+        var displayedLength;
+        var pendingPtDist = 0;
+        var pendingPtX;
+        var pendingPtY;
+        if (drawPart) {
+            if (!this._pathSegLen) {
+                this._calculateLength();
+            }
+            pathSegLen = this._pathSegLen;
+            pathTotalLen = this._pathLen;
+            displayedLength = percent * pathTotalLen;
+            if (!displayedLength) {
+                return;
+            }
+        }
+        lo: for (var i = 0; i < len;) {
+            var cmd = d[i++];
+            var isFirst = i === 1;
+            if (isFirst) {
+                xi = d[i];
+                yi = d[i + 1];
+                x0 = xi;
+                y0 = yi;
+            }
+            if (cmd !== CMD.L && pendingPtDist > 0) {
+                ctx.lineTo(pendingPtX, pendingPtY);
+                pendingPtDist = 0;
+            }
+            switch (cmd) {
+                case CMD.M:
+                    x0 = xi = d[i++];
+                    y0 = yi = d[i++];
+                    ctx.moveTo(xi, yi);
+                    break;
+                case CMD.L: {
+                    x = d[i++];
+                    y = d[i++];
+                    var dx = mathAbs(x - xi);
+                    var dy = mathAbs(y - yi);
+                    if (dx > ux || dy > uy) {
+                        if (drawPart) {
+                            var l = pathSegLen[segCount++];
+                            if (accumLength + l > displayedLength) {
+                                var t = (displayedLength - accumLength) / l;
+                                ctx.lineTo(xi * (1 - t) + x * t, yi * (1 - t) + y * t);
+                                break lo;
+                            }
+                            accumLength += l;
+                        }
+                        ctx.lineTo(x, y);
+                        xi = x;
+                        yi = y;
+                        pendingPtDist = 0;
+                    }
+                    else {
+                        var d2 = dx * dx + dy * dy;
+                        if (d2 > pendingPtDist) {
+                            pendingPtX = x;
+                            pendingPtY = y;
+                            pendingPtDist = d2;
+                        }
+                    }
+                    break;
+                }
+                case CMD.C: {
+                    var x1 = d[i++];
+                    var y1 = d[i++];
+                    var x2 = d[i++];
+                    var y2 = d[i++];
+                    var x3 = d[i++];
+                    var y3 = d[i++];
+                    if (drawPart) {
+                        var l = pathSegLen[segCount++];
+                        if (accumLength + l > displayedLength) {
+                            var t = (displayedLength - accumLength) / l;
+                            cubicSubdivide(xi, x1, x2, x3, t, tmpOutX);
+                            cubicSubdivide(yi, y1, y2, y3, t, tmpOutY);
+                            ctx.bezierCurveTo(tmpOutX[1], tmpOutY[1], tmpOutX[2], tmpOutY[2], tmpOutX[3], tmpOutY[3]);
+                            break lo;
+                        }
+                        accumLength += l;
+                    }
+                    ctx.bezierCurveTo(x1, y1, x2, y2, x3, y3);
+                    xi = x3;
+                    yi = y3;
+                    break;
+                }
+                case CMD.Q: {
+                    var x1 = d[i++];
+                    var y1 = d[i++];
+                    var x2 = d[i++];
+                    var y2 = d[i++];
+                    if (drawPart) {
+                        var l = pathSegLen[segCount++];
+                        if (accumLength + l > displayedLength) {
+                            var t = (displayedLength - accumLength) / l;
+                            quadraticSubdivide(xi, x1, x2, t, tmpOutX);
+                            quadraticSubdivide(yi, y1, y2, t, tmpOutY);
+                            ctx.quadraticCurveTo(tmpOutX[1], tmpOutY[1], tmpOutX[2], tmpOutY[2]);
+                            break lo;
+                        }
+                        accumLength += l;
+                    }
+                    ctx.quadraticCurveTo(x1, y1, x2, y2);
+                    xi = x2;
+                    yi = y2;
+                    break;
+                }
+                case CMD.A:
+                    var cx = d[i++];
+                    var cy = d[i++];
+                    var rx = d[i++];
+                    var ry = d[i++];
+                    var startAngle = d[i++];
+                    var delta = d[i++];
+                    var psi = d[i++];
+                    var anticlockwise = !d[i++];
+                    var r = (rx > ry) ? rx : ry;
+                    var isEllipse = mathAbs(rx - ry) > 1e-3;
+                    var endAngle = startAngle + delta;
+                    var breakBuild = false;
+                    if (drawPart) {
+                        var l = pathSegLen[segCount++];
+                        if (accumLength + l > displayedLength) {
+                            endAngle = startAngle + delta * (displayedLength - accumLength) / l;
+                            breakBuild = true;
+                        }
+                        accumLength += l;
+                    }
+                    if (isEllipse && ctx.ellipse) {
+                        ctx.ellipse(cx, cy, rx, ry, psi, startAngle, endAngle, anticlockwise);
+                    }
+                    else {
+                        ctx.arc(cx, cy, r, startAngle, endAngle, anticlockwise);
+                    }
+                    if (breakBuild) {
+                        break lo;
+                    }
+                    if (isFirst) {
+                        x0 = mathCos(startAngle) * rx + cx;
+                        y0 = mathSin(startAngle) * ry + cy;
+                    }
+                    xi = mathCos(endAngle) * rx + cx;
+                    yi = mathSin(endAngle) * ry + cy;
+                    break;
+                case CMD.R:
+                    x0 = xi = d[i];
+                    y0 = yi = d[i + 1];
+                    x = d[i++];
+                    y = d[i++];
+                    var width = d[i++];
+                    var height = d[i++];
+                    if (drawPart) {
+                        var l = pathSegLen[segCount++];
+                        if (accumLength + l > displayedLength) {
+                            var d_1 = displayedLength - accumLength;
+                            ctx.moveTo(x, y);
+                            ctx.lineTo(x + mathMin(d_1, width), y);
+                            d_1 -= width;
+                            if (d_1 > 0) {
+                                ctx.lineTo(x + width, y + mathMin(d_1, height));
+                            }
+                            d_1 -= height;
+                            if (d_1 > 0) {
+                                ctx.lineTo(x + mathMax(width - d_1, 0), y + height);
+                            }
+                            d_1 -= width;
+                            if (d_1 > 0) {
+                                ctx.lineTo(x, y + mathMax(height - d_1, 0));
+                            }
+                            break lo;
+                        }
+                        accumLength += l;
+                    }
+                    ctx.rect(x, y, width, height);
+                    break;
+                case CMD.Z:
+                    if (drawPart) {
+                        var l = pathSegLen[segCount++];
+                        if (accumLength + l > displayedLength) {
+                            var t = (displayedLength - accumLength) / l;
+                            ctx.lineTo(xi * (1 - t) + x0 * t, yi * (1 - t) + y0 * t);
+                            break lo;
+                        }
+                        accumLength += l;
+                    }
+                    ctx.closePath();
+                    xi = x0;
+                    yi = y0;
+            }
+        }
+    };
+    PathProxy.prototype.clone = function () {
+        var newProxy = new PathProxy();
+        var data = this.data;
+        newProxy.data = data.slice ? data.slice()
+            : Array.prototype.slice.call(data);
+        newProxy._len = this._len;
+        return newProxy;
+    };
+    PathProxy.CMD = CMD;
+    PathProxy.initDefaultProps = (function () {
+        var proto = PathProxy.prototype;
+        proto._saveData = true;
+        proto._ux = 0;
+        proto._uy = 0;
+        proto._pendingPtDist = 0;
+        proto._version = 0;
+    })();
+    return PathProxy;
+}());
+export default PathProxy;

uni-demo/node_modules/zrender/lib/core/Point.d.ts

@@ -0,0 +1,38 @@
+import { MatrixArray } from './matrix';
+export interface PointLike {
+    x: number;
+    y: number;
+}
+export default class Point {
+    x: number;
+    y: number;
+    constructor(x?: number, y?: number);
+    copy(other: PointLike): this;
+    clone(): Point;
+    set(x: number, y: number): this;
+    equal(other: PointLike): boolean;
+    add(other: PointLike): this;
+    scale(scalar: number): void;
+    scaleAndAdd(other: PointLike, scalar: number): void;
+    sub(other: PointLike): this;
+    dot(other: PointLike): number;
+    len(): number;
+    lenSquare(): number;
+    normalize(): this;
+    distance(other: PointLike): number;
+    distanceSquare(other: Point): number;
+    negate(): this;
+    transform(m: MatrixArray): this;
+    toArray(out: number[]): number[];
+    fromArray(input: number[]): void;
+    static set(p: PointLike, x: number, y: number): void;
+    static copy(p: PointLike, p2: PointLike): void;
+    static len(p: PointLike): number;
+    static lenSquare(p: PointLike): number;
+    static dot(p0: PointLike, p1: PointLike): number;
+    static add(out: PointLike, p0: PointLike, p1: PointLike): void;
+    static sub(out: PointLike, p0: PointLike, p1: PointLike): void;
+    static scale(out: PointLike, p0: PointLike, scalar: number): void;
+    static scaleAndAdd(out: PointLike, p0: PointLike, p1: PointLike, scalar: number): void;
+    static lerp(out: PointLike, p0: PointLike, p1: PointLike, t: number): void;
+}

uni-demo/node_modules/zrender/lib/core/Point.js

@@ -0,0 +1,129 @@
+var Point = (function () {
+    function Point(x, y) {
+        this.x = x || 0;
+        this.y = y || 0;
+    }
+    Point.prototype.copy = function (other) {
+        this.x = other.x;
+        this.y = other.y;
+        return this;
+    };
+    Point.prototype.clone = function () {
+        return new Point(this.x, this.y);
+    };
+    Point.prototype.set = function (x, y) {
+        this.x = x;
+        this.y = y;
+        return this;
+    };
+    Point.prototype.equal = function (other) {
+        return other.x === this.x && other.y === this.y;
+    };
+    Point.prototype.add = function (other) {
+        this.x += other.x;
+        this.y += other.y;
+        return this;
+    };
+    Point.prototype.scale = function (scalar) {
+        this.x *= scalar;
+        this.y *= scalar;
+    };
+    Point.prototype.scaleAndAdd = function (other, scalar) {
+        this.x += other.x * scalar;
+        this.y += other.y * scalar;
+    };
+    Point.prototype.sub = function (other) {
+        this.x -= other.x;
+        this.y -= other.y;
+        return this;
+    };
+    Point.prototype.dot = function (other) {
+        return this.x * other.x + this.y * other.y;
+    };
+    Point.prototype.len = function () {
+        return Math.sqrt(this.x * this.x + this.y * this.y);
+    };
+    Point.prototype.lenSquare = function () {
+        return this.x * this.x + this.y * this.y;
+    };
+    Point.prototype.normalize = function () {
+        var len = this.len();
+        this.x /= len;
+        this.y /= len;
+        return this;
+    };
+    Point.prototype.distance = function (other) {
+        var dx = this.x - other.x;
+        var dy = this.y - other.y;
+        return Math.sqrt(dx * dx + dy * dy);
+    };
+    Point.prototype.distanceSquare = function (other) {
+        var dx = this.x - other.x;
+        var dy = this.y - other.y;
+        return dx * dx + dy * dy;
+    };
+    Point.prototype.negate = function () {
+        this.x = -this.x;
+        this.y = -this.y;
+        return this;
+    };
+    Point.prototype.transform = function (m) {
+        if (!m) {
+            return;
+        }
+        var x = this.x;
+        var y = this.y;
+        this.x = m[0] * x + m[2] * y + m[4];
+        this.y = m[1] * x + m[3] * y + m[5];
+        return this;
+    };
+    Point.prototype.toArray = function (out) {
+        out[0] = this.x;
+        out[1] = this.y;
+        return out;
+    };
+    Point.prototype.fromArray = function (input) {
+        this.x = input[0];
+        this.y = input[1];
+    };
+    Point.set = function (p, x, y) {
+        p.x = x;
+        p.y = y;
+    };
+    Point.copy = function (p, p2) {
+        p.x = p2.x;
+        p.y = p2.y;
+    };
+    Point.len = function (p) {
+        return Math.sqrt(p.x * p.x + p.y * p.y);
+    };
+    Point.lenSquare = function (p) {
+        return p.x * p.x + p.y * p.y;
+    };
+    Point.dot = function (p0, p1) {
+        return p0.x * p1.x + p0.y * p1.y;
+    };
+    Point.add = function (out, p0, p1) {
+        out.x = p0.x + p1.x;
+        out.y = p0.y + p1.y;
+    };
+    Point.sub = function (out, p0, p1) {
+        out.x = p0.x - p1.x;
+        out.y = p0.y - p1.y;
+    };
+    Point.scale = function (out, p0, scalar) {
+        out.x = p0.x * scalar;
+        out.y = p0.y * scalar;
+    };
+    Point.scaleAndAdd = function (out, p0, p1, scalar) {
+        out.x = p0.x + p1.x * scalar;
+        out.y = p0.y + p1.y * scalar;
+    };
+    Point.lerp = function (out, p0, p1, t) {
+        var onet = 1 - t;
+        out.x = onet * p0.x + t * p1.x;
+        out.y = onet * p0.y + t * p1.y;
+    };
+    return Point;
+}());
+export default Point;

uni-demo/node_modules/zrender/lib/core/Transformable.d.ts

@@ -0,0 +1,41 @@
+import * as matrix from './matrix';
+import * as vector from './vector';
+declare class Transformable {
+    parent: Transformable;
+    x: number;
+    y: number;
+    scaleX: number;
+    scaleY: number;
+    skewX: number;
+    skewY: number;
+    rotation: number;
+    anchorX: number;
+    anchorY: number;
+    originX: number;
+    originY: number;
+    globalScaleRatio: number;
+    transform: matrix.MatrixArray;
+    invTransform: matrix.MatrixArray;
+    getLocalTransform(m?: matrix.MatrixArray): matrix.MatrixArray;
+    setPosition(arr: number[]): void;
+    setScale(arr: number[]): void;
+    setSkew(arr: number[]): void;
+    setOrigin(arr: number[]): void;
+    needLocalTransform(): boolean;
+    updateTransform(): void;
+    private _resolveGlobalScaleRatio;
+    getComputedTransform(): matrix.MatrixArray;
+    setLocalTransform(m: vector.VectorArray): void;
+    decomposeTransform(): void;
+    getGlobalScale(out?: vector.VectorArray): vector.VectorArray;
+    transformCoordToLocal(x: number, y: number): number[];
+    transformCoordToGlobal(x: number, y: number): number[];
+    getLineScale(): number;
+    copyTransform(source: Transformable): void;
+    static getLocalTransform(target: Transformable, m?: matrix.MatrixArray): matrix.MatrixArray;
+    private static initDefaultProps;
+}
+export declare const TRANSFORMABLE_PROPS: readonly ["x", "y", "originX", "originY", "anchorX", "anchorY", "rotation", "scaleX", "scaleY", "skewX", "skewY"];
+export declare type TransformProp = (typeof TRANSFORMABLE_PROPS)[number];
+export declare function copyTransform(target: Partial<Pick<Transformable, TransformProp>>, source: Pick<Transformable, TransformProp>): void;
+export default Transformable;

uni-demo/node_modules/zrender/lib/core/Transformable.js

@@ -0,0 +1,240 @@
+import * as matrix from './matrix.js';
+import * as vector from './vector.js';
+var mIdentity = matrix.identity;
+var EPSILON = 5e-5;
+function isNotAroundZero(val) {
+    return val > EPSILON || val < -EPSILON;
+}
+var scaleTmp = [];
+var tmpTransform = [];
+var originTransform = matrix.create();
+var abs = Math.abs;
+var Transformable = (function () {
+    function Transformable() {
+    }
+    Transformable.prototype.getLocalTransform = function (m) {
+        return Transformable.getLocalTransform(this, m);
+    };
+    Transformable.prototype.setPosition = function (arr) {
+        this.x = arr[0];
+        this.y = arr[1];
+    };
+    Transformable.prototype.setScale = function (arr) {
+        this.scaleX = arr[0];
+        this.scaleY = arr[1];
+    };
+    Transformable.prototype.setSkew = function (arr) {
+        this.skewX = arr[0];
+        this.skewY = arr[1];
+    };
+    Transformable.prototype.setOrigin = function (arr) {
+        this.originX = arr[0];
+        this.originY = arr[1];
+    };
+    Transformable.prototype.needLocalTransform = function () {
+        return isNotAroundZero(this.rotation)
+            || isNotAroundZero(this.x)
+            || isNotAroundZero(this.y)
+            || isNotAroundZero(this.scaleX - 1)
+            || isNotAroundZero(this.scaleY - 1)
+            || isNotAroundZero(this.skewX)
+            || isNotAroundZero(this.skewY);
+    };
+    Transformable.prototype.updateTransform = function () {
+        var parentTransform = this.parent && this.parent.transform;
+        var needLocalTransform = this.needLocalTransform();
+        var m = this.transform;
+        if (!(needLocalTransform || parentTransform)) {
+            m && mIdentity(m);
+            return;
+        }
+        m = m || matrix.create();
+        if (needLocalTransform) {
+            this.getLocalTransform(m);
+        }
+        else {
+            mIdentity(m);
+        }
+        if (parentTransform) {
+            if (needLocalTransform) {
+                matrix.mul(m, parentTransform, m);
+            }
+            else {
+                matrix.copy(m, parentTransform);
+            }
+        }
+        this.transform = m;
+        this._resolveGlobalScaleRatio(m);
+    };
+    Transformable.prototype._resolveGlobalScaleRatio = function (m) {
+        var globalScaleRatio = this.globalScaleRatio;
+        if (globalScaleRatio != null && globalScaleRatio !== 1) {
+            this.getGlobalScale(scaleTmp);
+            var relX = scaleTmp[0] < 0 ? -1 : 1;
+            var relY = scaleTmp[1] < 0 ? -1 : 1;
+            var sx = ((scaleTmp[0] - relX) * globalScaleRatio + relX) / scaleTmp[0] || 0;
+            var sy = ((scaleTmp[1] - relY) * globalScaleRatio + relY) / scaleTmp[1] || 0;
+            m[0] *= sx;
+            m[1] *= sx;
+            m[2] *= sy;
+            m[3] *= sy;
+        }
+        this.invTransform = this.invTransform || matrix.create();
+        matrix.invert(this.invTransform, m);
+    };
+    Transformable.prototype.getComputedTransform = function () {
+        var transformNode = this;
+        var ancestors = [];
+        while (transformNode) {
+            ancestors.push(transformNode);
+            transformNode = transformNode.parent;
+        }
+        while (transformNode = ancestors.pop()) {
+            transformNode.updateTransform();
+        }
+        return this.transform;
+    };
+    Transformable.prototype.setLocalTransform = function (m) {
+        if (!m) {
+            return;
+        }
+        var sx = m[0] * m[0] + m[1] * m[1];
+        var sy = m[2] * m[2] + m[3] * m[3];
+        var rotation = Math.atan2(m[1], m[0]);
+        var shearX = Math.PI / 2 + rotation - Math.atan2(m[3], m[2]);
+        sy = Math.sqrt(sy) * Math.cos(shearX);
+        sx = Math.sqrt(sx);
+        this.skewX = shearX;
+        this.skewY = 0;
+        this.rotation = -rotation;
+        this.x = +m[4];
+        this.y = +m[5];
+        this.scaleX = sx;
+        this.scaleY = sy;
+        this.originX = 0;
+        this.originY = 0;
+    };
+    Transformable.prototype.decomposeTransform = function () {
+        if (!this.transform) {
+            return;
+        }
+        var parent = this.parent;
+        var m = this.transform;
+        if (parent && parent.transform) {
+            matrix.mul(tmpTransform, parent.invTransform, m);
+            m = tmpTransform;
+        }
+        var ox = this.originX;
+        var oy = this.originY;
+        if (ox || oy) {
+            originTransform[4] = ox;
+            originTransform[5] = oy;
+            matrix.mul(tmpTransform, m, originTransform);
+            tmpTransform[4] -= ox;
+            tmpTransform[5] -= oy;
+            m = tmpTransform;
+        }
+        this.setLocalTransform(m);
+    };
+    Transformable.prototype.getGlobalScale = function (out) {
+        var m = this.transform;
+        out = out || [];
+        if (!m) {
+            out[0] = 1;
+            out[1] = 1;
+            return out;
+        }
+        out[0] = Math.sqrt(m[0] * m[0] + m[1] * m[1]);
+        out[1] = Math.sqrt(m[2] * m[2] + m[3] * m[3]);
+        if (m[0] < 0) {
+            out[0] = -out[0];
+        }
+        if (m[3] < 0) {
+            out[1] = -out[1];
+        }
+        return out;
+    };
+    Transformable.prototype.transformCoordToLocal = function (x, y) {
+        var v2 = [x, y];
+        var invTransform = this.invTransform;
+        if (invTransform) {
+            vector.applyTransform(v2, v2, invTransform);
+        }
+        return v2;
+    };
+    Transformable.prototype.transformCoordToGlobal = function (x, y) {
+        var v2 = [x, y];
+        var transform = this.transform;
+        if (transform) {
+            vector.applyTransform(v2, v2, transform);
+        }
+        return v2;
+    };
+    Transformable.prototype.getLineScale = function () {
+        var m = this.transform;
+        return m && abs(m[0] - 1) > 1e-10 && abs(m[3] - 1) > 1e-10
+            ? Math.sqrt(abs(m[0] * m[3] - m[2] * m[1]))
+            : 1;
+    };
+    Transformable.prototype.copyTransform = function (source) {
+        copyTransform(this, source);
+    };
+    Transformable.getLocalTransform = function (target, m) {
+        m = m || [];
+        var ox = target.originX || 0;
+        var oy = target.originY || 0;
+        var sx = target.scaleX;
+        var sy = target.scaleY;
+        var ax = target.anchorX;
+        var ay = target.anchorY;
+        var rotation = target.rotation || 0;
+        var x = target.x;
+        var y = target.y;
+        var skewX = target.skewX ? Math.tan(target.skewX) : 0;
+        var skewY = target.skewY ? Math.tan(-target.skewY) : 0;
+        if (ox || oy || ax || ay) {
+            var dx = ox + ax;
+            var dy = oy + ay;
+            m[4] = -dx * sx - skewX * dy * sy;
+            m[5] = -dy * sy - skewY * dx * sx;
+        }
+        else {
+            m[4] = m[5] = 0;
+        }
+        m[0] = sx;
+        m[3] = sy;
+        m[1] = skewY * sx;
+        m[2] = skewX * sy;
+        rotation && matrix.rotate(m, m, rotation);
+        m[4] += ox + x;
+        m[5] += oy + y;
+        return m;
+    };
+    Transformable.initDefaultProps = (function () {
+        var proto = Transformable.prototype;
+        proto.scaleX =
+            proto.scaleY =
+                proto.globalScaleRatio = 1;
+        proto.x =
+            proto.y =
+                proto.originX =
+                    proto.originY =
+                        proto.skewX =
+                            proto.skewY =
+                                proto.rotation =
+                                    proto.anchorX =
+                                        proto.anchorY = 0;
+    })();
+    return Transformable;
+}());
+;
+export var TRANSFORMABLE_PROPS = [
+    'x', 'y', 'originX', 'originY', 'anchorX', 'anchorY', 'rotation', 'scaleX', 'scaleY', 'skewX', 'skewY'
+];
+export function copyTransform(target, source) {
+    for (var i = 0; i < TRANSFORMABLE_PROPS.length; i++) {
+        var propName = TRANSFORMABLE_PROPS[i];
+        target[propName] = source[propName];
+    }
+}
+export default Transformable;

uni-demo/node_modules/zrender/lib/core/WeakMap.d.ts

@@ -0,0 +1,9 @@
+export default class WeakMap<K extends object, V> {
+    protected _id: string;
+    constructor();
+    get(key: K): V;
+    set(key: K, value: V): WeakMap<K, V>;
+    delete(key: K): boolean;
+    has(key: K): boolean;
+    protected _guard(key: K): K;
+}

uni-demo/node_modules/zrender/lib/core/WeakMap.js

@@ -0,0 +1,42 @@
+var wmUniqueIndex = Math.round(Math.random() * 9);
+var supportDefineProperty = typeof Object.defineProperty === 'function';
+var WeakMap = (function () {
+    function WeakMap() {
+        this._id = '__ec_inner_' + wmUniqueIndex++;
+    }
+    WeakMap.prototype.get = function (key) {
+        return this._guard(key)[this._id];
+    };
+    WeakMap.prototype.set = function (key, value) {
+        var target = this._guard(key);
+        if (supportDefineProperty) {
+            Object.defineProperty(target, this._id, {
+                value: value,
+                enumerable: false,
+                configurable: true
+            });
+        }
+        else {
+            target[this._id] = value;
+        }
+        return this;
+    };
+    WeakMap.prototype["delete"] = function (key) {
+        if (this.has(key)) {
+            delete this._guard(key)[this._id];
+            return true;
+        }
+        return false;
+    };
+    WeakMap.prototype.has = function (key) {
+        return !!this._guard(key)[this._id];
+    };
+    WeakMap.prototype._guard = function (key) {
+        if (key !== Object(key)) {
+            throw TypeError('Value of WeakMap is not a non-null object.');
+        }
+        return key;
+    };
+    return WeakMap;
+}());
+export default WeakMap;

uni-demo/node_modules/zrender/lib/core/arrayDiff.d.ts

@@ -0,0 +1,9 @@
+declare type EqualFunc<T> = (a: T, b: T) => boolean;
+declare type DiffComponent = {
+    count: number;
+    added: boolean;
+    removed: boolean;
+    indices: number[];
+};
+export default function arrayDiff<T>(oldArr: T[], newArr: T[], equal?: EqualFunc<T>): DiffComponent[];
+export {};

uni-demo/node_modules/zrender/lib/core/arrayDiff.js

@@ -0,0 +1,145 @@
+function diff(oldArr, newArr, equals) {
+    if (!equals) {
+        equals = function (a, b) {
+            return a === b;
+        };
+    }
+    oldArr = oldArr.slice();
+    newArr = newArr.slice();
+    var newLen = newArr.length;
+    var oldLen = oldArr.length;
+    var editLength = 1;
+    var maxEditLength = newLen + oldLen;
+    var bestPath = [{ newPos: -1, components: [] }];
+    var oldPos = extractCommon(bestPath[0], newArr, oldArr, 0, equals);
+    if (!oldLen
+        || !newLen
+        || (bestPath[0].newPos + 1 >= newLen && oldPos + 1 >= oldLen)) {
+        var indices = [];
+        var allCleared = !newLen && oldLen > 0;
+        var allCreated = !oldLen && newLen > 0;
+        for (var i = 0; i < (allCleared ? oldArr : newArr).length; i++) {
+            indices.push(i);
+        }
+        return [{
+                indices: indices,
+                count: indices.length,
+                added: allCreated,
+                removed: allCleared
+            }];
+    }
+    function execEditLength() {
+        for (var diagonalPath = -1 * editLength; diagonalPath <= editLength; diagonalPath += 2) {
+            var basePath;
+            var addPath = bestPath[diagonalPath - 1];
+            var removePath = bestPath[diagonalPath + 1];
+            var oldPos = (removePath ? removePath.newPos : 0) - diagonalPath;
+            if (addPath) {
+                bestPath[diagonalPath - 1] = undefined;
+            }
+            var canAdd = addPath && addPath.newPos + 1 < newLen;
+            var canRemove = removePath && 0 <= oldPos && oldPos < oldLen;
+            if (!canAdd && !canRemove) {
+                bestPath[diagonalPath] = undefined;
+                continue;
+            }
+            if (!canAdd || (canRemove && addPath.newPos < removePath.newPos)) {
+                basePath = clonePath(removePath);
+                pushComponent(basePath.components, false, true);
+            }
+            else {
+                basePath = addPath;
+                basePath.newPos++;
+                pushComponent(basePath.components, true, false);
+            }
+            oldPos = extractCommon(basePath, newArr, oldArr, diagonalPath, equals);
+            if (basePath.newPos + 1 >= newLen && oldPos + 1 >= oldLen) {
+                return buildValues(basePath.components);
+            }
+            else {
+                bestPath[diagonalPath] = basePath;
+            }
+        }
+        editLength++;
+    }
+    while (editLength <= maxEditLength) {
+        var ret = execEditLength();
+        if (ret) {
+            return ret;
+        }
+    }
+}
+function extractCommon(basePath, newArr, oldArr, diagonalPath, equals) {
+    var newLen = newArr.length;
+    var oldLen = oldArr.length;
+    var newPos = basePath.newPos;
+    var oldPos = newPos - diagonalPath;
+    var commonCount = 0;
+    while (newPos + 1 < newLen && oldPos + 1 < oldLen && equals(newArr[newPos + 1], oldArr[oldPos + 1])) {
+        newPos++;
+        oldPos++;
+        commonCount++;
+    }
+    if (commonCount) {
+        basePath.components.push({
+            count: commonCount,
+            added: false,
+            removed: false,
+            indices: []
+        });
+    }
+    basePath.newPos = newPos;
+    return oldPos;
+}
+function pushComponent(components, added, removed) {
+    var last = components[components.length - 1];
+    if (last && last.added === added && last.removed === removed) {
+        components[components.length - 1] = {
+            count: last.count + 1,
+            added: added,
+            removed: removed,
+            indices: []
+        };
+    }
+    else {
+        components.push({
+            count: 1,
+            added: added,
+            removed: removed,
+            indices: []
+        });
+    }
+}
+function buildValues(components) {
+    var componentPos = 0;
+    var componentLen = components.length;
+    var newPos = 0;
+    var oldPos = 0;
+    for (; componentPos < componentLen; componentPos++) {
+        var component = components[componentPos];
+        if (!component.removed) {
+            var indices = [];
+            for (var i = newPos; i < newPos + component.count; i++) {
+                indices.push(i);
+            }
+            component.indices = indices;
+            newPos += component.count;
+            if (!component.added) {
+                oldPos += component.count;
+            }
+        }
+        else {
+            for (var i = oldPos; i < oldPos + component.count; i++) {
+                component.indices.push(i);
+            }
+            oldPos += component.count;
+        }
+    }
+    return components;
+}
+function clonePath(path) {
+    return { newPos: path.newPos, components: path.components.slice(0) };
+}
+export default function arrayDiff(oldArr, newArr, equal) {
+    return diff(oldArr, newArr, equal);
+}

uni-demo/node_modules/zrender/lib/core/bbox.d.ts

@@ -0,0 +1,6 @@
+import * as vec2 from './vector';
+export declare function fromPoints(points: ArrayLike<number>[], min: vec2.VectorArray, max: vec2.VectorArray): void;
+export declare function fromLine(x0: number, y0: number, x1: number, y1: number, min: vec2.VectorArray, max: vec2.VectorArray): void;
+export declare function fromCubic(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, min: vec2.VectorArray, max: vec2.VectorArray): void;
+export declare function fromQuadratic(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, min: vec2.VectorArray, max: vec2.VectorArray): void;
+export declare function fromArc(x: number, y: number, rx: number, ry: number, startAngle: number, endAngle: number, anticlockwise: boolean, min: vec2.VectorArray, max: vec2.VectorArray): void;

uni-demo/node_modules/zrender/lib/core/bbox.js

@@ -0,0 +1,124 @@
+import * as vec2 from './vector.js';
+import * as curve from './curve.js';
+var mathMin = Math.min;
+var mathMax = Math.max;
+var mathSin = Math.sin;
+var mathCos = Math.cos;
+var PI2 = Math.PI * 2;
+var start = vec2.create();
+var end = vec2.create();
+var extremity = vec2.create();
+export function fromPoints(points, min, max) {
+    if (points.length === 0) {
+        return;
+    }
+    var p = points[0];
+    var left = p[0];
+    var right = p[0];
+    var top = p[1];
+    var bottom = p[1];
+    for (var i = 1; i < points.length; i++) {
+        p = points[i];
+        left = mathMin(left, p[0]);
+        right = mathMax(right, p[0]);
+        top = mathMin(top, p[1]);
+        bottom = mathMax(bottom, p[1]);
+    }
+    min[0] = left;
+    min[1] = top;
+    max[0] = right;
+    max[1] = bottom;
+}
+export function fromLine(x0, y0, x1, y1, min, max) {
+    min[0] = mathMin(x0, x1);
+    min[1] = mathMin(y0, y1);
+    max[0] = mathMax(x0, x1);
+    max[1] = mathMax(y0, y1);
+}
+var xDim = [];
+var yDim = [];
+export function fromCubic(x0, y0, x1, y1, x2, y2, x3, y3, min, max) {
+    var cubicExtrema = curve.cubicExtrema;
+    var cubicAt = curve.cubicAt;
+    var n = cubicExtrema(x0, x1, x2, x3, xDim);
+    min[0] = Infinity;
+    min[1] = Infinity;
+    max[0] = -Infinity;
+    max[1] = -Infinity;
+    for (var i = 0; i < n; i++) {
+        var x = cubicAt(x0, x1, x2, x3, xDim[i]);
+        min[0] = mathMin(x, min[0]);
+        max[0] = mathMax(x, max[0]);
+    }
+    n = cubicExtrema(y0, y1, y2, y3, yDim);
+    for (var i = 0; i < n; i++) {
+        var y = cubicAt(y0, y1, y2, y3, yDim[i]);
+        min[1] = mathMin(y, min[1]);
+        max[1] = mathMax(y, max[1]);
+    }
+    min[0] = mathMin(x0, min[0]);
+    max[0] = mathMax(x0, max[0]);
+    min[0] = mathMin(x3, min[0]);
+    max[0] = mathMax(x3, max[0]);
+    min[1] = mathMin(y0, min[1]);
+    max[1] = mathMax(y0, max[1]);
+    min[1] = mathMin(y3, min[1]);
+    max[1] = mathMax(y3, max[1]);
+}
+export function fromQuadratic(x0, y0, x1, y1, x2, y2, min, max) {
+    var quadraticExtremum = curve.quadraticExtremum;
+    var quadraticAt = curve.quadraticAt;
+    var tx = mathMax(mathMin(quadraticExtremum(x0, x1, x2), 1), 0);
+    var ty = mathMax(mathMin(quadraticExtremum(y0, y1, y2), 1), 0);
+    var x = quadraticAt(x0, x1, x2, tx);
+    var y = quadraticAt(y0, y1, y2, ty);
+    min[0] = mathMin(x0, x2, x);
+    min[1] = mathMin(y0, y2, y);
+    max[0] = mathMax(x0, x2, x);
+    max[1] = mathMax(y0, y2, y);
+}
+export function fromArc(x, y, rx, ry, startAngle, endAngle, anticlockwise, min, max) {
+    var vec2Min = vec2.min;
+    var vec2Max = vec2.max;
+    var diff = Math.abs(startAngle - endAngle);
+    if (diff % PI2 < 1e-4 && diff > 1e-4) {
+        min[0] = x - rx;
+        min[1] = y - ry;
+        max[0] = x + rx;
+        max[1] = y + ry;
+        return;
+    }
+    start[0] = mathCos(startAngle) * rx + x;
+    start[1] = mathSin(startAngle) * ry + y;
+    end[0] = mathCos(endAngle) * rx + x;
+    end[1] = mathSin(endAngle) * ry + y;
+    vec2Min(min, start, end);
+    vec2Max(max, start, end);
+    startAngle = startAngle % (PI2);
+    if (startAngle < 0) {
+        startAngle = startAngle + PI2;
+    }
+    endAngle = endAngle % (PI2);
+    if (endAngle < 0) {
+        endAngle = endAngle + PI2;
+    }
+    if (startAngle > endAngle && !anticlockwise) {
+        endAngle += PI2;
+    }
+    else if (startAngle < endAngle && anticlockwise) {
+        startAngle += PI2;
+    }
+    if (anticlockwise) {
+        var tmp = endAngle;
+        endAngle = startAngle;
+        startAngle = tmp;
+    }
+    for (var angle = 0; angle < endAngle; angle += Math.PI / 2) {
+        if (angle > startAngle) {
+            extremity[0] = mathCos(angle) * rx + x;
+            extremity[1] = mathSin(angle) * ry + y;
+            vec2Min(min, extremity, min);
+            vec2Max(max, extremity, max);
+        }
+    }
+}

uni-demo/node_modules/zrender/lib/core/curve.d.ts

@@ -0,0 +1,15 @@
+import { VectorArray } from './vector';
+export declare function cubicAt(p0: number, p1: number, p2: number, p3: number, t: number): number;
+export declare function cubicDerivativeAt(p0: number, p1: number, p2: number, p3: number, t: number): number;
+export declare function cubicRootAt(p0: number, p1: number, p2: number, p3: number, val: number, roots: number[]): number;
+export declare function cubicExtrema(p0: number, p1: number, p2: number, p3: number, extrema: number[]): number;
+export declare function cubicSubdivide(p0: number, p1: number, p2: number, p3: number, t: number, out: number[]): void;
+export declare function cubicProjectPoint(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, x: number, y: number, out: VectorArray): number;
+export declare function cubicLength(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, iteration: number): number;
+export declare function quadraticAt(p0: number, p1: number, p2: number, t: number): number;
+export declare function quadraticDerivativeAt(p0: number, p1: number, p2: number, t: number): number;
+export declare function quadraticRootAt(p0: number, p1: number, p2: number, val: number, roots: number[]): number;
+export declare function quadraticExtremum(p0: number, p1: number, p2: number): number;
+export declare function quadraticSubdivide(p0: number, p1: number, p2: number, t: number, out: number[]): void;
+export declare function quadraticProjectPoint(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x: number, y: number, out: VectorArray): number;
+export declare function quadraticLength(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, iteration: number): number;

uni-demo/node_modules/zrender/lib/core/curve.js

@@ -0,0 +1,345 @@
+import { create as v2Create, distSquare as v2DistSquare } from './vector.js';
+var mathPow = Math.pow;
+var mathSqrt = Math.sqrt;
+var EPSILON = 1e-8;
+var EPSILON_NUMERIC = 1e-4;
+var THREE_SQRT = mathSqrt(3);
+var ONE_THIRD = 1 / 3;
+var _v0 = v2Create();
+var _v1 = v2Create();
+var _v2 = v2Create();
+function isAroundZero(val) {
+    return val > -EPSILON && val < EPSILON;
+}
+function isNotAroundZero(val) {
+    return val > EPSILON || val < -EPSILON;
+}
+export function cubicAt(p0, p1, p2, p3, t) {
+    var onet = 1 - t;
+    return onet * onet * (onet * p0 + 3 * t * p1)
+        + t * t * (t * p3 + 3 * onet * p2);
+}
+export function cubicDerivativeAt(p0, p1, p2, p3, t) {
+    var onet = 1 - t;
+    return 3 * (((p1 - p0) * onet + 2 * (p2 - p1) * t) * onet
+        + (p3 - p2) * t * t);
+}
+export function cubicRootAt(p0, p1, p2, p3, val, roots) {
+    var a = p3 + 3 * (p1 - p2) - p0;
+    var b = 3 * (p2 - p1 * 2 + p0);
+    var c = 3 * (p1 - p0);
+    var d = p0 - val;
+    var A = b * b - 3 * a * c;
+    var B = b * c - 9 * a * d;
+    var C = c * c - 3 * b * d;
+    var n = 0;
+    if (isAroundZero(A) && isAroundZero(B)) {
+        if (isAroundZero(b)) {
+            roots[0] = 0;
+        }
+        else {
+            var t1 = -c / b;
+            if (t1 >= 0 && t1 <= 1) {
+                roots[n++] = t1;
+            }
+        }
+    }
+    else {
+        var disc = B * B - 4 * A * C;
+        if (isAroundZero(disc)) {
+            var K = B / A;
+            var t1 = -b / a + K;
+            var t2 = -K / 2;
+            if (t1 >= 0 && t1 <= 1) {
+                roots[n++] = t1;
+            }
+            if (t2 >= 0 && t2 <= 1) {
+                roots[n++] = t2;
+            }
+        }
+        else if (disc > 0) {
+            var discSqrt = mathSqrt(disc);
+            var Y1 = A * b + 1.5 * a * (-B + discSqrt);
+            var Y2 = A * b + 1.5 * a * (-B - discSqrt);
+            if (Y1 < 0) {
+                Y1 = -mathPow(-Y1, ONE_THIRD);
+            }
+            else {
+                Y1 = mathPow(Y1, ONE_THIRD);
+            }
+            if (Y2 < 0) {
+                Y2 = -mathPow(-Y2, ONE_THIRD);
+            }
+            else {
+                Y2 = mathPow(Y2, ONE_THIRD);
+            }
+            var t1 = (-b - (Y1 + Y2)) / (3 * a);
+            if (t1 >= 0 && t1 <= 1) {
+                roots[n++] = t1;
+            }
+        }
+        else {
+            var T = (2 * A * b - 3 * a * B) / (2 * mathSqrt(A * A * A));
+            var theta = Math.acos(T) / 3;
+            var ASqrt = mathSqrt(A);
+            var tmp = Math.cos(theta);
+            var t1 = (-b - 2 * ASqrt * tmp) / (3 * a);
+            var t2 = (-b + ASqrt * (tmp + THREE_SQRT * Math.sin(theta))) / (3 * a);
+            var t3 = (-b + ASqrt * (tmp - THREE_SQRT * Math.sin(theta))) / (3 * a);
+            if (t1 >= 0 && t1 <= 1) {
+                roots[n++] = t1;
+            }
+            if (t2 >= 0 && t2 <= 1) {
+                roots[n++] = t2;
+            }
+            if (t3 >= 0 && t3 <= 1) {
+                roots[n++] = t3;
+            }
+        }
+    }
+    return n;
+}
+export function cubicExtrema(p0, p1, p2, p3, extrema) {
+    var b = 6 * p2 - 12 * p1 + 6 * p0;
+    var a = 9 * p1 + 3 * p3 - 3 * p0 - 9 * p2;
+    var c = 3 * p1 - 3 * p0;
+    var n = 0;
+    if (isAroundZero(a)) {
+        if (isNotAroundZero(b)) {
+            var t1 = -c / b;
+            if (t1 >= 0 && t1 <= 1) {
+                extrema[n++] = t1;
+            }
+        }
+    }
+    else {
+        var disc = b * b - 4 * a * c;
+        if (isAroundZero(disc)) {
+            extrema[0] = -b / (2 * a);
+        }
+        else if (disc > 0) {
+            var discSqrt = mathSqrt(disc);
+            var t1 = (-b + discSqrt) / (2 * a);
+            var t2 = (-b - discSqrt) / (2 * a);
+            if (t1 >= 0 && t1 <= 1) {
+                extrema[n++] = t1;
+            }
+            if (t2 >= 0 && t2 <= 1) {
+                extrema[n++] = t2;
+            }
+        }
+    }
+    return n;
+}
+export function cubicSubdivide(p0, p1, p2, p3, t, out) {
+    var p01 = (p1 - p0) * t + p0;
+    var p12 = (p2 - p1) * t + p1;
+    var p23 = (p3 - p2) * t + p2;
+    var p012 = (p12 - p01) * t + p01;
+    var p123 = (p23 - p12) * t + p12;
+    var p0123 = (p123 - p012) * t + p012;
+    out[0] = p0;
+    out[1] = p01;
+    out[2] = p012;
+    out[3] = p0123;
+    out[4] = p0123;
+    out[5] = p123;
+    out[6] = p23;
+    out[7] = p3;
+}
+export function cubicProjectPoint(x0, y0, x1, y1, x2, y2, x3, y3, x, y, out) {
+    var t;
+    var interval = 0.005;
+    var d = Infinity;
+    var prev;
+    var next;
+    var d1;
+    var d2;
+    _v0[0] = x;
+    _v0[1] = y;
+    for (var _t = 0; _t < 1; _t += 0.05) {
+        _v1[0] = cubicAt(x0, x1, x2, x3, _t);
+        _v1[1] = cubicAt(y0, y1, y2, y3, _t);
+        d1 = v2DistSquare(_v0, _v1);
+        if (d1 < d) {
+            t = _t;
+            d = d1;
+        }
+    }
+    d = Infinity;
+    for (var i = 0; i < 32; i++) {
+        if (interval < EPSILON_NUMERIC) {
+            break;
+        }
+        prev = t - interval;
+        next = t + interval;
+        _v1[0] = cubicAt(x0, x1, x2, x3, prev);
+        _v1[1] = cubicAt(y0, y1, y2, y3, prev);
+        d1 = v2DistSquare(_v1, _v0);
+        if (prev >= 0 && d1 < d) {
+            t = prev;
+            d = d1;
+        }
+        else {
+            _v2[0] = cubicAt(x0, x1, x2, x3, next);
+            _v2[1] = cubicAt(y0, y1, y2, y3, next);
+            d2 = v2DistSquare(_v2, _v0);
+            if (next <= 1 && d2 < d) {
+                t = next;
+                d = d2;
+            }
+            else {
+                interval *= 0.5;
+            }
+        }
+    }
+    if (out) {
+        out[0] = cubicAt(x0, x1, x2, x3, t);
+        out[1] = cubicAt(y0, y1, y2, y3, t);
+    }
+    return mathSqrt(d);
+}
+export function cubicLength(x0, y0, x1, y1, x2, y2, x3, y3, iteration) {
+    var px = x0;
+    var py = y0;
+    var d = 0;
+    var step = 1 / iteration;
+    for (var i = 1; i <= iteration; i++) {
+        var t = i * step;
+        var x = cubicAt(x0, x1, x2, x3, t);
+        var y = cubicAt(y0, y1, y2, y3, t);
+        var dx = x - px;
+        var dy = y - py;
+        d += Math.sqrt(dx * dx + dy * dy);
+        px = x;
+        py = y;
+    }
+    return d;
+}
+export function quadraticAt(p0, p1, p2, t) {
+    var onet = 1 - t;
+    return onet * (onet * p0 + 2 * t * p1) + t * t * p2;
+}
+export function quadraticDerivativeAt(p0, p1, p2, t) {
+    return 2 * ((1 - t) * (p1 - p0) + t * (p2 - p1));
+}
+export function quadraticRootAt(p0, p1, p2, val, roots) {
+    var a = p0 - 2 * p1 + p2;
+    var b = 2 * (p1 - p0);
+    var c = p0 - val;
+    var n = 0;
+    if (isAroundZero(a)) {
+        if (isNotAroundZero(b)) {
+            var t1 = -c / b;
+            if (t1 >= 0 && t1 <= 1) {
+                roots[n++] = t1;
+            }
+        }
+    }
+    else {
+        var disc = b * b - 4 * a * c;
+        if (isAroundZero(disc)) {
+            var t1 = -b / (2 * a);
+            if (t1 >= 0 && t1 <= 1) {
+                roots[n++] = t1;
+            }
+        }
+        else if (disc > 0) {
+            var discSqrt = mathSqrt(disc);
+            var t1 = (-b + discSqrt) / (2 * a);
+            var t2 = (-b - discSqrt) / (2 * a);
+            if (t1 >= 0 && t1 <= 1) {
+                roots[n++] = t1;
+            }
+            if (t2 >= 0 && t2 <= 1) {
+                roots[n++] = t2;
+            }
+        }
+    }
+    return n;
+}
+export function quadraticExtremum(p0, p1, p2) {
+    var divider = p0 + p2 - 2 * p1;
+    if (divider === 0) {
+        return 0.5;
+    }
+    else {
+        return (p0 - p1) / divider;
+    }
+}
+export function quadraticSubdivide(p0, p1, p2, t, out) {
+    var p01 = (p1 - p0) * t + p0;
+    var p12 = (p2 - p1) * t + p1;
+    var p012 = (p12 - p01) * t + p01;
+    out[0] = p0;
+    out[1] = p01;
+    out[2] = p012;
+    out[3] = p012;
+    out[4] = p12;
+    out[5] = p2;
+}
+export function quadraticProjectPoint(x0, y0, x1, y1, x2, y2, x, y, out) {
+    var t;
+    var interval = 0.005;
+    var d = Infinity;
+    _v0[0] = x;
+    _v0[1] = y;
+    for (var _t = 0; _t < 1; _t += 0.05) {
+        _v1[0] = quadraticAt(x0, x1, x2, _t);
+        _v1[1] = quadraticAt(y0, y1, y2, _t);
+        var d1 = v2DistSquare(_v0, _v1);
+        if (d1 < d) {
+            t = _t;
+            d = d1;
+        }
+    }
+    d = Infinity;
+    for (var i = 0; i < 32; i++) {
+        if (interval < EPSILON_NUMERIC) {
+            break;
+        }
+        var prev = t - interval;
+        var next = t + interval;
+        _v1[0] = quadraticAt(x0, x1, x2, prev);
+        _v1[1] = quadraticAt(y0, y1, y2, prev);
+        var d1 = v2DistSquare(_v1, _v0);
+        if (prev >= 0 && d1 < d) {
+            t = prev;
+            d = d1;
+        }
+        else {
+            _v2[0] = quadraticAt(x0, x1, x2, next);
+            _v2[1] = quadraticAt(y0, y1, y2, next);
+            var d2 = v2DistSquare(_v2, _v0);
+            if (next <= 1 && d2 < d) {
+                t = next;
+                d = d2;
+            }
+            else {
+                interval *= 0.5;
+            }
+        }
+    }
+    if (out) {
+        out[0] = quadraticAt(x0, x1, x2, t);
+        out[1] = quadraticAt(y0, y1, y2, t);
+    }
+    return mathSqrt(d);
+}
+export function quadraticLength(x0, y0, x1, y1, x2, y2, iteration) {
+    var px = x0;
+    var py = y0;
+    var d = 0;
+    var step = 1 / iteration;
+    for (var i = 1; i <= iteration; i++) {
+        var t = i * step;
+        var x = quadraticAt(x0, x1, x2, t);
+        var y = quadraticAt(y0, y1, y2, t);
+        var dx = x - px;
+        var dy = y - py;
+        d += Math.sqrt(dx * dx + dy * dy);
+        px = x;
+        py = y;
+    }
+    return d;
+}

uni-demo/node_modules/zrender/lib/core/dom.d.ts

@@ -0,0 +1,3 @@
+export declare function transformLocalCoord(out: number[], elFrom: HTMLElement, elTarget: HTMLElement, inX: number, inY: number): boolean;
+export declare function transformCoordWithViewport(out: number[], el: HTMLElement, inX: number, inY: number, inverse?: boolean): boolean;
+export declare function isCanvasEl(el: HTMLElement): el is HTMLCanvasElement;

uni-demo/node_modules/zrender/lib/core/dom.js

@@ -0,0 +1,79 @@
+import env from './env.js';
+import { buildTransformer } from './fourPointsTransform.js';
+var EVENT_SAVED_PROP = '___zrEVENTSAVED';
+var _calcOut = [];
+export function transformLocalCoord(out, elFrom, elTarget, inX, inY) {
+    return transformCoordWithViewport(_calcOut, elFrom, inX, inY, true)
+        && transformCoordWithViewport(out, elTarget, _calcOut[0], _calcOut[1]);
+}
+export function transformCoordWithViewport(out, el, inX, inY, inverse) {
+    if (el.getBoundingClientRect && env.domSupported && !isCanvasEl(el)) {
+        var saved = el[EVENT_SAVED_PROP] || (el[EVENT_SAVED_PROP] = {});
+        var markers = prepareCoordMarkers(el, saved);
+        var transformer = preparePointerTransformer(markers, saved, inverse);
+        if (transformer) {
+            transformer(out, inX, inY);
+            return true;
+        }
+    }
+    return false;
+}
+function prepareCoordMarkers(el, saved) {
+    var markers = saved.markers;
+    if (markers) {
+        return markers;
+    }
+    markers = saved.markers = [];
+    var propLR = ['left', 'right'];
+    var propTB = ['top', 'bottom'];
+    for (var i = 0; i < 4; i++) {
+        var marker = document.createElement('div');
+        var stl = marker.style;
+        var idxLR = i % 2;
+        var idxTB = (i >> 1) % 2;
+        stl.cssText = [
+            'position: absolute',
+            'visibility: hidden',
+            'padding: 0',
+            'margin: 0',
+            'border-width: 0',
+            'user-select: none',
+            'width:0',
+            'height:0',
+            propLR[idxLR] + ':0',
+            propTB[idxTB] + ':0',
+            propLR[1 - idxLR] + ':auto',
+            propTB[1 - idxTB] + ':auto',
+            ''
+        ].join('!important;');
+        el.appendChild(marker);
+        markers.push(marker);
+    }
+    return markers;
+}
+function preparePointerTransformer(markers, saved, inverse) {
+    var transformerName = inverse ? 'invTrans' : 'trans';
+    var transformer = saved[transformerName];
+    var oldSrcCoords = saved.srcCoords;
+    var srcCoords = [];
+    var destCoords = [];
+    var oldCoordTheSame = true;
+    for (var i = 0; i < 4; i++) {
+        var rect = markers[i].getBoundingClientRect();
+        var ii = 2 * i;
+        var x = rect.left;
+        var y = rect.top;
+        srcCoords.push(x, y);
+        oldCoordTheSame = oldCoordTheSame && oldSrcCoords && x === oldSrcCoords[ii] && y === oldSrcCoords[ii + 1];
+        destCoords.push(markers[i].offsetLeft, markers[i].offsetTop);
+    }
+    return (oldCoordTheSame && transformer)
+        ? transformer
+        : (saved.srcCoords = srcCoords,
+            saved[transformerName] = inverse
+                ? buildTransformer(destCoords, srcCoords)
+                : buildTransformer(srcCoords, destCoords));
+}
+export function isCanvasEl(el) {
+    return el.nodeName.toUpperCase() === 'CANVAS';
+}

uni-demo/node_modules/zrender/lib/core/env.d.ts

@@ -0,0 +1,23 @@
+declare class Browser {
+    firefox: boolean;
+    ie: boolean;
+    edge: boolean;
+    newEdge: boolean;
+    weChat: boolean;
+    version: string | number;
+}
+declare class Env {
+    browser: Browser;
+    node: boolean;
+    wxa: boolean;
+    worker: boolean;
+    svgSupported: boolean;
+    touchEventsSupported: boolean;
+    pointerEventsSupported: boolean;
+    domSupported: boolean;
+    transformSupported: boolean;
+    transform3dSupported: boolean;
+    hasGlobalWindow: boolean;
+}
+declare const env: Env;
+export default env;

uni-demo/node_modules/zrender/lib/core/env.js

@@ -0,0 +1,79 @@
+var Browser = (function () {
+    function Browser() {
+        this.firefox = false;
+        this.ie = false;
+        this.edge = false;
+        this.newEdge = false;
+        this.weChat = false;
+    }
+    return Browser;
+}());
+var Env = (function () {
+    function Env() {
+        this.browser = new Browser();
+        this.node = false;
+        this.wxa = false;
+        this.worker = false;
+        this.svgSupported = false;
+        this.touchEventsSupported = false;
+        this.pointerEventsSupported = false;
+        this.domSupported = false;
+        this.transformSupported = false;
+        this.transform3dSupported = false;
+        this.hasGlobalWindow = typeof window !== 'undefined';
+    }
+    return Env;
+}());
+var env = new Env();
+if (typeof wx === 'object' && typeof wx.getSystemInfoSync === 'function') {
+    env.wxa = true;
+    env.touchEventsSupported = true;
+}
+else if (typeof document === 'undefined' && typeof self !== 'undefined') {
+    env.worker = true;
+}
+else if (typeof navigator === 'undefined') {
+    env.node = true;
+    env.svgSupported = true;
+}
+else {
+    detect(navigator.userAgent, env);
+}
+function detect(ua, env) {
+    var browser = env.browser;
+    var firefox = ua.match(/Firefox\/([\d.]+)/);
+    var ie = ua.match(/MSIE\s([\d.]+)/)
+        || ua.match(/Trident\/.+?rv:(([\d.]+))/);
+    var edge = ua.match(/Edge?\/([\d.]+)/);
+    var weChat = (/micromessenger/i).test(ua);
+    if (firefox) {
+        browser.firefox = true;
+        browser.version = firefox[1];
+    }
+    if (ie) {
+        browser.ie = true;
+        browser.version = ie[1];
+    }
+    if (edge) {
+        browser.edge = true;
+        browser.version = edge[1];
+        browser.newEdge = +edge[1].split('.')[0] > 18;
+    }
+    if (weChat) {
+        browser.weChat = true;
+    }
+    env.svgSupported = typeof SVGRect !== 'undefined';
+    env.touchEventsSupported = 'ontouchstart' in window && !browser.ie && !browser.edge;
+    env.pointerEventsSupported = 'onpointerdown' in window
+        && (browser.edge || (browser.ie && +browser.version >= 11));
+    env.domSupported = typeof document !== 'undefined';
+    var style = document.documentElement.style;
+    env.transform3dSupported = ((browser.ie && 'transition' in style)
+        || browser.edge
+        || (('WebKitCSSMatrix' in window) && ('m11' in new WebKitCSSMatrix()))
+        || 'MozPerspective' in style)
+        && !('OTransition' in style);
+    env.transformSupported = env.transform3dSupported
+        || (browser.ie && +browser.version >= 9);
+}
+export default env;

uni-demo/node_modules/zrender/lib/core/event.d.ts

@@ -0,0 +1,24 @@
+import Eventful from './Eventful';
+import { ZRRawEvent } from './types';
+declare type FirefoxMouseEvent = {
+    layerX: number;
+    layerY: number;
+};
+export declare function clientToLocal(el: HTMLElement, e: ZRRawEvent | FirefoxMouseEvent | Touch, out: {
+    zrX?: number;
+    zrY?: number;
+}, calculate?: boolean): {
+    zrX?: number;
+    zrY?: number;
+};
+export declare function getNativeEvent(e: ZRRawEvent): ZRRawEvent;
+export declare function normalizeEvent(el: HTMLElement, e: ZRRawEvent, calculate?: boolean): ZRRawEvent;
+declare type AddEventListenerParams = Parameters<typeof HTMLElement.prototype.addEventListener>;
+declare type RemoveEventListenerParams = Parameters<typeof HTMLElement.prototype.removeEventListener>;
+export declare function addEventListener(el: HTMLElement | HTMLDocument, name: AddEventListenerParams[0], handler: AddEventListenerParams[1], opt?: AddEventListenerParams[2]): void;
+export declare function removeEventListener(el: HTMLElement | HTMLDocument, name: RemoveEventListenerParams[0], handler: RemoveEventListenerParams[1], opt: RemoveEventListenerParams[2]): void;
+export declare const stop: (e: MouseEvent | TouchEvent | PointerEvent) => void;
+export declare function isMiddleOrRightButtonOnMouseUpDown(e: {
+    which: number;
+}): boolean;
+export { Eventful as Dispatcher };

uni-demo/node_modules/zrender/lib/core/event.js

@@ -0,0 +1,107 @@
+import Eventful from './Eventful.js';
+import env from './env.js';
+import { isCanvasEl, transformCoordWithViewport } from './dom.js';
+var MOUSE_EVENT_REG = /^(?:mouse|pointer|contextmenu|drag|drop)|click/;
+var _calcOut = [];
+var firefoxNotSupportOffsetXY = env.browser.firefox
+    && +env.browser.version.split('.')[0] < 39;
+export function clientToLocal(el, e, out, calculate) {
+    out = out || {};
+    if (calculate) {
+        calculateZrXY(el, e, out);
+    }
+    else if (firefoxNotSupportOffsetXY
+        && e.layerX != null
+        && e.layerX !== e.offsetX) {
+        out.zrX = e.layerX;
+        out.zrY = e.layerY;
+    }
+    else if (e.offsetX != null) {
+        out.zrX = e.offsetX;
+        out.zrY = e.offsetY;
+    }
+    else {
+        calculateZrXY(el, e, out);
+    }
+    return out;
+}
+function calculateZrXY(el, e, out) {
+    if (env.domSupported && el.getBoundingClientRect) {
+        var ex = e.clientX;
+        var ey = e.clientY;
+        if (isCanvasEl(el)) {
+            var box = el.getBoundingClientRect();
+            out.zrX = ex - box.left;
+            out.zrY = ey - box.top;
+            return;
+        }
+        else {
+            if (transformCoordWithViewport(_calcOut, el, ex, ey)) {
+                out.zrX = _calcOut[0];
+                out.zrY = _calcOut[1];
+                return;
+            }
+        }
+    }
+    out.zrX = out.zrY = 0;
+}
+export function getNativeEvent(e) {
+    return e
+        || window.event;
+}
+export function normalizeEvent(el, e, calculate) {
+    e = getNativeEvent(e);
+    if (e.zrX != null) {
+        return e;
+    }
+    var eventType = e.type;
+    var isTouch = eventType && eventType.indexOf('touch') >= 0;
+    if (!isTouch) {
+        clientToLocal(el, e, e, calculate);
+        var wheelDelta = getWheelDeltaMayPolyfill(e);
+        e.zrDelta = wheelDelta ? wheelDelta / 120 : -(e.detail || 0) / 3;
+    }
+    else {
+        var touch = eventType !== 'touchend'
+            ? e.targetTouches[0]
+            : e.changedTouches[0];
+        touch && clientToLocal(el, touch, e, calculate);
+    }
+    var button = e.button;
+    if (e.which == null && button !== undefined && MOUSE_EVENT_REG.test(e.type)) {
+        e.which = (button & 1 ? 1 : (button & 2 ? 3 : (button & 4 ? 2 : 0)));
+    }
+    return e;
+}
+function getWheelDeltaMayPolyfill(e) {
+    var rawWheelDelta = e.wheelDelta;
+    if (rawWheelDelta) {
+        return rawWheelDelta;
+    }
+    var deltaX = e.deltaX;
+    var deltaY = e.deltaY;
+    if (deltaX == null || deltaY == null) {
+        return rawWheelDelta;
+    }
+    var delta = deltaY !== 0 ? Math.abs(deltaY) : Math.abs(deltaX);
+    var sign = deltaY > 0 ? -1
+        : deltaY < 0 ? 1
+            : deltaX > 0 ? -1
+                : 1;
+    return 3 * delta * sign;
+}
+export function addEventListener(el, name, handler, opt) {
+    el.addEventListener(name, handler, opt);
+}
+export function removeEventListener(el, name, handler, opt) {
+    el.removeEventListener(name, handler, opt);
+}
+export var stop = function (e) {
+    e.preventDefault();
+    e.stopPropagation();
+    e.cancelBubble = true;
+};
+export function isMiddleOrRightButtonOnMouseUpDown(e) {
+    return e.which === 2 || e.which === 3;
+}
+export { Eventful as Dispatcher };

uni-demo/node_modules/zrender/lib/core/fourPointsTransform.d.ts

@@ -0,0 +1 @@
+export declare function buildTransformer(src: number[], dest: number[]): (out: number[], srcPointX: number, srcPointY: number) => void;

uni-demo/node_modules/zrender/lib/core/fourPointsTransform.js

@@ -0,0 +1,59 @@
+var LN2 = Math.log(2);
+function determinant(rows, rank, rowStart, rowMask, colMask, detCache) {
+    var cacheKey = rowMask + '-' + colMask;
+    var fullRank = rows.length;
+    if (detCache.hasOwnProperty(cacheKey)) {
+        return detCache[cacheKey];
+    }
+    if (rank === 1) {
+        var colStart = Math.round(Math.log(((1 << fullRank) - 1) & ~colMask) / LN2);
+        return rows[rowStart][colStart];
+    }
+    var subRowMask = rowMask | (1 << rowStart);
+    var subRowStart = rowStart + 1;
+    while (rowMask & (1 << subRowStart)) {
+        subRowStart++;
+    }
+    var sum = 0;
+    for (var j = 0, colLocalIdx = 0; j < fullRank; j++) {
+        var colTag = 1 << j;
+        if (!(colTag & colMask)) {
+            sum += (colLocalIdx % 2 ? -1 : 1) * rows[rowStart][j]
+                * determinant(rows, rank - 1, subRowStart, subRowMask, colMask | colTag, detCache);
+            colLocalIdx++;
+        }
+    }
+    detCache[cacheKey] = sum;
+    return sum;
+}
+export function buildTransformer(src, dest) {
+    var mA = [
+        [src[0], src[1], 1, 0, 0, 0, -dest[0] * src[0], -dest[0] * src[1]],
+        [0, 0, 0, src[0], src[1], 1, -dest[1] * src[0], -dest[1] * src[1]],
+        [src[2], src[3], 1, 0, 0, 0, -dest[2] * src[2], -dest[2] * src[3]],
+        [0, 0, 0, src[2], src[3], 1, -dest[3] * src[2], -dest[3] * src[3]],
+        [src[4], src[5], 1, 0, 0, 0, -dest[4] * src[4], -dest[4] * src[5]],
+        [0, 0, 0, src[4], src[5], 1, -dest[5] * src[4], -dest[5] * src[5]],
+        [src[6], src[7], 1, 0, 0, 0, -dest[6] * src[6], -dest[6] * src[7]],
+        [0, 0, 0, src[6], src[7], 1, -dest[7] * src[6], -dest[7] * src[7]]
+    ];
+    var detCache = {};
+    var det = determinant(mA, 8, 0, 0, 0, detCache);
+    if (det === 0) {
+        return;
+    }
+    var vh = [];
+    for (var i = 0; i < 8; i++) {
+        for (var j = 0; j < 8; j++) {
+            vh[j] == null && (vh[j] = 0);
+            vh[j] += ((i + j) % 2 ? -1 : 1)
+                * determinant(mA, 7, i === 0 ? 1 : 0, 1 << i, 1 << j, detCache)
+                / det * dest[i];
+        }
+    }
+    return function (out, srcPointX, srcPointY) {
+        var pk = srcPointX * vh[6] + srcPointY * vh[7] + 1;
+        out[0] = (srcPointX * vh[0] + srcPointY * vh[1] + vh[2]) / pk;
+        out[1] = (srcPointX * vh[3] + srcPointY * vh[4] + vh[5]) / pk;
+    };
+}

uni-demo/node_modules/zrender/lib/core/matrix.d.ts

@@ -0,0 +1,11 @@
+import { VectorArray } from './vector';
+export declare type MatrixArray = number[];
+export declare function create(): MatrixArray;
+export declare function identity(out: MatrixArray): MatrixArray;
+export declare function copy(out: MatrixArray, m: MatrixArray): MatrixArray;
+export declare function mul(out: MatrixArray, m1: MatrixArray, m2: MatrixArray): MatrixArray;
+export declare function translate(out: MatrixArray, a: MatrixArray, v: VectorArray): MatrixArray;
+export declare function rotate(out: MatrixArray, a: MatrixArray, rad: number): MatrixArray;
+export declare function scale(out: MatrixArray, a: MatrixArray, v: VectorArray): MatrixArray;
+export declare function invert(out: MatrixArray, a: MatrixArray): MatrixArray | null;
+export declare function clone(a: MatrixArray): MatrixArray;

uni-demo/node_modules/zrender/lib/core/matrix.js

@@ -0,0 +1,98 @@
+export function create() {
+    return [1, 0, 0, 1, 0, 0];
+}
+export function identity(out) {
+    out[0] = 1;
+    out[1] = 0;
+    out[2] = 0;
+    out[3] = 1;
+    out[4] = 0;
+    out[5] = 0;
+    return out;
+}
+export function copy(out, m) {
+    out[0] = m[0];
+    out[1] = m[1];
+    out[2] = m[2];
+    out[3] = m[3];
+    out[4] = m[4];
+    out[5] = m[5];
+    return out;
+}
+export function mul(out, m1, m2) {
+    var out0 = m1[0] * m2[0] + m1[2] * m2[1];
+    var out1 = m1[1] * m2[0] + m1[3] * m2[1];
+    var out2 = m1[0] * m2[2] + m1[2] * m2[3];
+    var out3 = m1[1] * m2[2] + m1[3] * m2[3];
+    var out4 = m1[0] * m2[4] + m1[2] * m2[5] + m1[4];
+    var out5 = m1[1] * m2[4] + m1[3] * m2[5] + m1[5];
+    out[0] = out0;
+    out[1] = out1;
+    out[2] = out2;
+    out[3] = out3;
+    out[4] = out4;
+    out[5] = out5;
+    return out;
+}
+export function translate(out, a, v) {
+    out[0] = a[0];
+    out[1] = a[1];
+    out[2] = a[2];
+    out[3] = a[3];
+    out[4] = a[4] + v[0];
+    out[5] = a[5] + v[1];
+    return out;
+}
+export function rotate(out, a, rad) {
+    var aa = a[0];
+    var ac = a[2];
+    var atx = a[4];
+    var ab = a[1];
+    var ad = a[3];
+    var aty = a[5];
+    var st = Math.sin(rad);
+    var ct = Math.cos(rad);
+    out[0] = aa * ct + ab * st;
+    out[1] = -aa * st + ab * ct;
+    out[2] = ac * ct + ad * st;
+    out[3] = -ac * st + ct * ad;
+    out[4] = ct * atx + st * aty;
+    out[5] = ct * aty - st * atx;
+    return out;
+}
+export function scale(out, a, v) {
+    var vx = v[0];
+    var vy = v[1];
+    out[0] = a[0] * vx;
+    out[1] = a[1] * vy;
+    out[2] = a[2] * vx;
+    out[3] = a[3] * vy;
+    out[4] = a[4] * vx;
+    out[5] = a[5] * vy;
+    return out;
+}
+export function invert(out, a) {
+    var aa = a[0];
+    var ac = a[2];
+    var atx = a[4];
+    var ab = a[1];
+    var ad = a[3];
+    var aty = a[5];
+    var det = aa * ad - ab * ac;
+    if (!det) {
+        return null;
+    }
+    det = 1.0 / det;
+    out[0] = ad * det;
+    out[1] = -ab * det;
+    out[2] = -ac * det;
+    out[3] = aa * det;
+    out[4] = (ac * aty - ad * atx) * det;
+    out[5] = (ab * atx - aa * aty) * det;
+    return out;
+}
+export function clone(a) {
+    var b = create();
+    copy(b, a);
+    return b;
+}

uni-demo/node_modules/zrender/lib/core/platform.d.ts

@@ -0,0 +1,14 @@
+export declare const DEFAULT_FONT_SIZE = 12;
+export declare const DEFAULT_FONT_FAMILY = "sans-serif";
+export declare const DEFAULT_FONT: string;
+interface Platform {
+    createCanvas(): HTMLCanvasElement;
+    measureText(text: string, font?: string): {
+        width: number;
+    };
+    loadImage(src: string, onload: () => void | HTMLImageElement['onload'], onerror: () => void | HTMLImageElement['onerror']): HTMLImageElement;
+}
+export declare const DEFAULT_TEXT_WIDTH_MAP: Record<string, number>;
+export declare const platformApi: Platform;
+export declare function setPlatformAPI(newPlatformApis: Partial<Platform>): void;
+export {};

uni-demo/node_modules/zrender/lib/core/platform.js

@@ -0,0 +1,72 @@
+export var DEFAULT_FONT_SIZE = 12;
+export var DEFAULT_FONT_FAMILY = 'sans-serif';
+export var DEFAULT_FONT = DEFAULT_FONT_SIZE + "px " + DEFAULT_FONT_FAMILY;
+var OFFSET = 20;
+var SCALE = 100;
+var defaultWidthMapStr = "007LLmW'55;N0500LLLLLLLLLL00NNNLzWW\\\\WQb\\0FWLg\\bWb\\WQ\\WrWWQ000CL5LLFLL0LL**F*gLLLL5F0LF\\FFF5.5N";
+function getTextWidthMap(mapStr) {
+    var map = {};
+    if (typeof JSON === 'undefined') {
+        return map;
+    }
+    for (var i = 0; i < mapStr.length; i++) {
+        var char = String.fromCharCode(i + 32);
+        var size = (mapStr.charCodeAt(i) - OFFSET) / SCALE;
+        map[char] = size;
+    }
+    return map;
+}
+export var DEFAULT_TEXT_WIDTH_MAP = getTextWidthMap(defaultWidthMapStr);
+export var platformApi = {
+    createCanvas: function () {
+        return typeof document !== 'undefined'
+            && document.createElement('canvas');
+    },
+    measureText: (function () {
+        var _ctx;
+        var _cachedFont;
+        return function (text, font) {
+            if (!_ctx) {
+                var canvas = platformApi.createCanvas();
+                _ctx = canvas && canvas.getContext('2d');
+            }
+            if (_ctx) {
+                if (_cachedFont !== font) {
+                    _cachedFont = _ctx.font = font || DEFAULT_FONT;
+                }
+                return _ctx.measureText(text);
+            }
+            else {
+                text = text || '';
+                font = font || DEFAULT_FONT;
+                var res = /^([0-9]*?)px$/.exec(font);
+                var fontSize = +(res && res[1]) || DEFAULT_FONT_SIZE;
+                var width = 0;
+                if (font.indexOf('mono') >= 0) {
+                    width = fontSize * text.length;
+                }
+                else {
+                    for (var i = 0; i < text.length; i++) {
+                        var preCalcWidth = DEFAULT_TEXT_WIDTH_MAP[text[i]];
+                        width += preCalcWidth == null ? fontSize : (preCalcWidth * fontSize);
+                    }
+                }
+                return { width: width };
+            }
+        };
+    })(),
+    loadImage: function (src, onload, onerror) {
+        var image = new Image();
+        image.onload = onload;
+        image.onerror = onerror;
+        image.src = src;
+        return image;
+    }
+};
+export function setPlatformAPI(newPlatformApis) {
+    for (var key in platformApi) {
+        if (newPlatformApis[key]) {
+            platformApi[key] = newPlatformApis[key];
+        }
+    }
+}

uni-demo/node_modules/zrender/lib/core/timsort.d.ts

@@ -0,0 +1,3 @@
+declare type CompareFunc<T> = (a: T, b: T) => number;
+export default function sort<T>(array: T[], compare: CompareFunc<T>, lo?: number, hi?: number): void;
+export {};

uni-demo/node_modules/zrender/lib/core/timsort.js

@@ -0,0 +1,531 @@
+var DEFAULT_MIN_MERGE = 32;
+var DEFAULT_MIN_GALLOPING = 7;
+var DEFAULT_TMP_STORAGE_LENGTH = 256;
+function minRunLength(n) {
+    var r = 0;
+    while (n >= DEFAULT_MIN_MERGE) {
+        r |= n & 1;
+        n >>= 1;
+    }
+    return n + r;
+}
+function makeAscendingRun(array, lo, hi, compare) {
+    var runHi = lo + 1;
+    if (runHi === hi) {
+        return 1;
+    }
+    if (compare(array[runHi++], array[lo]) < 0) {
+        while (runHi < hi && compare(array[runHi], array[runHi - 1]) < 0) {
+            runHi++;
+        }
+        reverseRun(array, lo, runHi);
+    }
+    else {
+        while (runHi < hi && compare(array[runHi], array[runHi - 1]) >= 0) {
+            runHi++;
+        }
+    }
+    return runHi - lo;
+}
+function reverseRun(array, lo, hi) {
+    hi--;
+    while (lo < hi) {
+        var t = array[lo];
+        array[lo++] = array[hi];
+        array[hi--] = t;
+    }
+}
+function binaryInsertionSort(array, lo, hi, start, compare) {
+    if (start === lo) {
+        start++;
+    }
+    for (; start < hi; start++) {
+        var pivot = array[start];
+        var left = lo;
+        var right = start;
+        var mid;
+        while (left < right) {
+            mid = left + right >>> 1;
+            if (compare(pivot, array[mid]) < 0) {
+                right = mid;
+            }
+            else {
+                left = mid + 1;
+            }
+        }
+        var n = start - left;
+        switch (n) {
+            case 3:
+                array[left + 3] = array[left + 2];
+            case 2:
+                array[left + 2] = array[left + 1];
+            case 1:
+                array[left + 1] = array[left];
+                break;
+            default:
+                while (n > 0) {
+                    array[left + n] = array[left + n - 1];
+                    n--;
+                }
+        }
+        array[left] = pivot;
+    }
+}
+function gallopLeft(value, array, start, length, hint, compare) {
+    var lastOffset = 0;
+    var maxOffset = 0;
+    var offset = 1;
+    if (compare(value, array[start + hint]) > 0) {
+        maxOffset = length - hint;
+        while (offset < maxOffset && compare(value, array[start + hint + offset]) > 0) {
+            lastOffset = offset;
+            offset = (offset << 1) + 1;
+            if (offset <= 0) {
+                offset = maxOffset;
+            }
+        }
+        if (offset > maxOffset) {
+            offset = maxOffset;
+        }
+        lastOffset += hint;
+        offset += hint;
+    }
+    else {
+        maxOffset = hint + 1;
+        while (offset < maxOffset && compare(value, array[start + hint - offset]) <= 0) {
+            lastOffset = offset;
+            offset = (offset << 1) + 1;
+            if (offset <= 0) {
+                offset = maxOffset;
+            }
+        }
+        if (offset > maxOffset) {
+            offset = maxOffset;
+        }
+        var tmp = lastOffset;
+        lastOffset = hint - offset;
+        offset = hint - tmp;
+    }
+    lastOffset++;
+    while (lastOffset < offset) {
+        var m = lastOffset + (offset - lastOffset >>> 1);
+        if (compare(value, array[start + m]) > 0) {
+            lastOffset = m + 1;
+        }
+        else {
+            offset = m;
+        }
+    }
+    return offset;
+}
+function gallopRight(value, array, start, length, hint, compare) {
+    var lastOffset = 0;
+    var maxOffset = 0;
+    var offset = 1;
+    if (compare(value, array[start + hint]) < 0) {
+        maxOffset = hint + 1;
+        while (offset < maxOffset && compare(value, array[start + hint - offset]) < 0) {
+            lastOffset = offset;
+            offset = (offset << 1) + 1;
+            if (offset <= 0) {
+                offset = maxOffset;
+            }
+        }
+        if (offset > maxOffset) {
+            offset = maxOffset;
+        }
+        var tmp = lastOffset;
+        lastOffset = hint - offset;
+        offset = hint - tmp;
+    }
+    else {
+        maxOffset = length - hint;
+        while (offset < maxOffset && compare(value, array[start + hint + offset]) >= 0) {
+            lastOffset = offset;
+            offset = (offset << 1) + 1;
+            if (offset <= 0) {
+                offset = maxOffset;
+            }
+        }
+        if (offset > maxOffset) {
+            offset = maxOffset;
+        }
+        lastOffset += hint;
+        offset += hint;
+    }
+    lastOffset++;
+    while (lastOffset < offset) {
+        var m = lastOffset + (offset - lastOffset >>> 1);
+        if (compare(value, array[start + m]) < 0) {
+            offset = m;
+        }
+        else {
+            lastOffset = m + 1;
+        }
+    }
+    return offset;
+}
+function TimSort(array, compare) {
+    var minGallop = DEFAULT_MIN_GALLOPING;
+    var length = 0;
+    var tmpStorageLength = DEFAULT_TMP_STORAGE_LENGTH;
+    var stackLength = 0;
+    var runStart;
+    var runLength;
+    var stackSize = 0;
+    length = array.length;
+    if (length < 2 * DEFAULT_TMP_STORAGE_LENGTH) {
+        tmpStorageLength = length >>> 1;
+    }
+    var tmp = [];
+    stackLength = length < 120 ? 5 : length < 1542 ? 10 : length < 119151 ? 19 : 40;
+    runStart = [];
+    runLength = [];
+    function pushRun(_runStart, _runLength) {
+        runStart[stackSize] = _runStart;
+        runLength[stackSize] = _runLength;
+        stackSize += 1;
+    }
+    function mergeRuns() {
+        while (stackSize > 1) {
+            var n = stackSize - 2;
+            if ((n >= 1 && runLength[n - 1] <= runLength[n] + runLength[n + 1])
+                || (n >= 2 && runLength[n - 2] <= runLength[n] + runLength[n - 1])) {
+                if (runLength[n - 1] < runLength[n + 1]) {
+                    n--;
+                }
+            }
+            else if (runLength[n] > runLength[n + 1]) {
+                break;
+            }
+            mergeAt(n);
+        }
+    }
+    function forceMergeRuns() {
+        while (stackSize > 1) {
+            var n = stackSize - 2;
+            if (n > 0 && runLength[n - 1] < runLength[n + 1]) {
+                n--;
+            }
+            mergeAt(n);
+        }
+    }
+    function mergeAt(i) {
+        var start1 = runStart[i];
+        var length1 = runLength[i];
+        var start2 = runStart[i + 1];
+        var length2 = runLength[i + 1];
+        runLength[i] = length1 + length2;
+        if (i === stackSize - 3) {
+            runStart[i + 1] = runStart[i + 2];
+            runLength[i + 1] = runLength[i + 2];
+        }
+        stackSize--;
+        var k = gallopRight(array[start2], array, start1, length1, 0, compare);
+        start1 += k;
+        length1 -= k;
+        if (length1 === 0) {
+            return;
+        }
+        length2 = gallopLeft(array[start1 + length1 - 1], array, start2, length2, length2 - 1, compare);
+        if (length2 === 0) {
+            return;
+        }
+        if (length1 <= length2) {
+            mergeLow(start1, length1, start2, length2);
+        }
+        else {
+            mergeHigh(start1, length1, start2, length2);
+        }
+    }
+    function mergeLow(start1, length1, start2, length2) {
+        var i = 0;
+        for (i = 0; i < length1; i++) {
+            tmp[i] = array[start1 + i];
+        }
+        var cursor1 = 0;
+        var cursor2 = start2;
+        var dest = start1;
+        array[dest++] = array[cursor2++];
+        if (--length2 === 0) {
+            for (i = 0; i < length1; i++) {
+                array[dest + i] = tmp[cursor1 + i];
+            }
+            return;
+        }
+        if (length1 === 1) {
+            for (i = 0; i < length2; i++) {
+                array[dest + i] = array[cursor2 + i];
+            }
+            array[dest + length2] = tmp[cursor1];
+            return;
+        }
+        var _minGallop = minGallop;
+        var count1;
+        var count2;
+        var exit;
+        while (1) {
+            count1 = 0;
+            count2 = 0;
+            exit = false;
+            do {
+                if (compare(array[cursor2], tmp[cursor1]) < 0) {
+                    array[dest++] = array[cursor2++];
+                    count2++;
+                    count1 = 0;
+                    if (--length2 === 0) {
+                        exit = true;
+                        break;
+                    }
+                }
+                else {
+                    array[dest++] = tmp[cursor1++];
+                    count1++;
+                    count2 = 0;
+                    if (--length1 === 1) {
+                        exit = true;
+                        break;
+                    }
+                }
+            } while ((count1 | count2) < _minGallop);
+            if (exit) {
+                break;
+            }
+            do {
+                count1 = gallopRight(array[cursor2], tmp, cursor1, length1, 0, compare);
+                if (count1 !== 0) {
+                    for (i = 0; i < count1; i++) {
+                        array[dest + i] = tmp[cursor1 + i];
+                    }
+                    dest += count1;
+                    cursor1 += count1;
+                    length1 -= count1;
+                    if (length1 <= 1) {
+                        exit = true;
+                        break;
+                    }
+                }
+                array[dest++] = array[cursor2++];
+                if (--length2 === 0) {
+                    exit = true;
+                    break;
+                }
+                count2 = gallopLeft(tmp[cursor1], array, cursor2, length2, 0, compare);
+                if (count2 !== 0) {
+                    for (i = 0; i < count2; i++) {
+                        array[dest + i] = array[cursor2 + i];
+                    }
+                    dest += count2;
+                    cursor2 += count2;
+                    length2 -= count2;
+                    if (length2 === 0) {
+                        exit = true;
+                        break;
+                    }
+                }
+                array[dest++] = tmp[cursor1++];
+                if (--length1 === 1) {
+                    exit = true;
+                    break;
+                }
+                _minGallop--;
+            } while (count1 >= DEFAULT_MIN_GALLOPING || count2 >= DEFAULT_MIN_GALLOPING);
+            if (exit) {
+                break;
+            }
+            if (_minGallop < 0) {
+                _minGallop = 0;
+            }
+            _minGallop += 2;
+        }
+        minGallop = _minGallop;
+        minGallop < 1 && (minGallop = 1);
+        if (length1 === 1) {
+            for (i = 0; i < length2; i++) {
+                array[dest + i] = array[cursor2 + i];
+            }
+            array[dest + length2] = tmp[cursor1];
+        }
+        else if (length1 === 0) {
+            throw new Error();
+        }
+        else {
+            for (i = 0; i < length1; i++) {
+                array[dest + i] = tmp[cursor1 + i];
+            }
+        }
+    }
+    function mergeHigh(start1, length1, start2, length2) {
+        var i = 0;
+        for (i = 0; i < length2; i++) {
+            tmp[i] = array[start2 + i];
+        }
+        var cursor1 = start1 + length1 - 1;
+        var cursor2 = length2 - 1;
+        var dest = start2 + length2 - 1;
+        var customCursor = 0;
+        var customDest = 0;
+        array[dest--] = array[cursor1--];
+        if (--length1 === 0) {
+            customCursor = dest - (length2 - 1);
+            for (i = 0; i < length2; i++) {
+                array[customCursor + i] = tmp[i];
+            }
+            return;
+        }
+        if (length2 === 1) {
+            dest -= length1;
+            cursor1 -= length1;
+            customDest = dest + 1;
+            customCursor = cursor1 + 1;
+            for (i = length1 - 1; i >= 0; i--) {
+                array[customDest + i] = array[customCursor + i];
+            }
+            array[dest] = tmp[cursor2];
+            return;
+        }
+        var _minGallop = minGallop;
+        while (true) {
+            var count1 = 0;
+            var count2 = 0;
+            var exit = false;
+            do {
+                if (compare(tmp[cursor2], array[cursor1]) < 0) {
+                    array[dest--] = array[cursor1--];
+                    count1++;
+                    count2 = 0;
+                    if (--length1 === 0) {
+                        exit = true;
+                        break;
+                    }
+                }
+                else {
+                    array[dest--] = tmp[cursor2--];
+                    count2++;
+                    count1 = 0;
+                    if (--length2 === 1) {
+                        exit = true;
+                        break;
+                    }
+                }
+            } while ((count1 | count2) < _minGallop);
+            if (exit) {
+                break;
+            }
+            do {
+                count1 = length1 - gallopRight(tmp[cursor2], array, start1, length1, length1 - 1, compare);
+                if (count1 !== 0) {
+                    dest -= count1;
+                    cursor1 -= count1;
+                    length1 -= count1;
+                    customDest = dest + 1;
+                    customCursor = cursor1 + 1;
+                    for (i = count1 - 1; i >= 0; i--) {
+                        array[customDest + i] = array[customCursor + i];
+                    }
+                    if (length1 === 0) {
+                        exit = true;
+                        break;
+                    }
+                }
+                array[dest--] = tmp[cursor2--];
+                if (--length2 === 1) {
+                    exit = true;
+                    break;
+                }
+                count2 = length2 - gallopLeft(array[cursor1], tmp, 0, length2, length2 - 1, compare);
+                if (count2 !== 0) {
+                    dest -= count2;
+                    cursor2 -= count2;
+                    length2 -= count2;
+                    customDest = dest + 1;
+                    customCursor = cursor2 + 1;
+                    for (i = 0; i < count2; i++) {
+                        array[customDest + i] = tmp[customCursor + i];
+                    }
+                    if (length2 <= 1) {
+                        exit = true;
+                        break;
+                    }
+                }
+                array[dest--] = array[cursor1--];
+                if (--length1 === 0) {
+                    exit = true;
+                    break;
+                }
+                _minGallop--;
+            } while (count1 >= DEFAULT_MIN_GALLOPING || count2 >= DEFAULT_MIN_GALLOPING);
+            if (exit) {
+                break;
+            }
+            if (_minGallop < 0) {
+                _minGallop = 0;
+            }
+            _minGallop += 2;
+        }
+        minGallop = _minGallop;
+        if (minGallop < 1) {
+            minGallop = 1;
+        }
+        if (length2 === 1) {
+            dest -= length1;
+            cursor1 -= length1;
+            customDest = dest + 1;
+            customCursor = cursor1 + 1;
+            for (i = length1 - 1; i >= 0; i--) {
+                array[customDest + i] = array[customCursor + i];
+            }
+            array[dest] = tmp[cursor2];
+        }
+        else if (length2 === 0) {
+            throw new Error();
+        }
+        else {
+            customCursor = dest - (length2 - 1);
+            for (i = 0; i < length2; i++) {
+                array[customCursor + i] = tmp[i];
+            }
+        }
+    }
+    return {
+        mergeRuns: mergeRuns,
+        forceMergeRuns: forceMergeRuns,
+        pushRun: pushRun
+    };
+}
+export default function sort(array, compare, lo, hi) {
+    if (!lo) {
+        lo = 0;
+    }
+    if (!hi) {
+        hi = array.length;
+    }
+    var remaining = hi - lo;
+    if (remaining < 2) {
+        return;
+    }
+    var runLength = 0;
+    if (remaining < DEFAULT_MIN_MERGE) {
+        runLength = makeAscendingRun(array, lo, hi, compare);
+        binaryInsertionSort(array, lo, hi, lo + runLength, compare);
+        return;
+    }
+    var ts = TimSort(array, compare);
+    var minRun = minRunLength(remaining);
+    do {
+        runLength = makeAscendingRun(array, lo, hi, compare);
+        if (runLength < minRun) {
+            var force = remaining;
+            if (force > minRun) {
+                force = minRun;
+            }
+            binaryInsertionSort(array, lo, lo + force, lo + runLength, compare);
+            runLength = force;
+        }
+        ts.pushRun(lo, runLength);
+        ts.mergeRuns();
+        remaining -= runLength;
+        lo += runLength;
+    } while (remaining !== 0);
+    ts.forceMergeRuns();
+}

uni-demo/node_modules/zrender/lib/core/types.d.ts

@@ -0,0 +1,53 @@
+export declare type Dictionary<T> = {
+    [key: string]: T;
+};
+export declare type ArrayLike<T> = {
+    [key: number]: T;
+    length: number;
+};
+export declare type ImageLike = HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
+export declare type TextVerticalAlign = 'top' | 'middle' | 'bottom';
+export declare type TextAlign = 'left' | 'center' | 'right';
+export declare type FontWeight = 'normal' | 'bold' | 'bolder' | 'lighter' | number;
+export declare type FontStyle = 'normal' | 'italic' | 'oblique';
+export declare type BuiltinTextPosition = 'left' | 'right' | 'top' | 'bottom' | 'inside' | 'insideLeft' | 'insideRight' | 'insideTop' | 'insideBottom' | 'insideTopLeft' | 'insideTopRight' | 'insideBottomLeft' | 'insideBottomRight';
+export declare type WXCanvasRenderingContext = CanvasRenderingContext2D & {
+    draw: () => void;
+};
+export declare type ZRCanvasRenderingContext = CanvasRenderingContext2D & {
+    dpr: number;
+    __attrCachedBy: boolean | number;
+};
+declare type ZREventProperties = {
+    zrX: number;
+    zrY: number;
+    zrDelta: number;
+    zrEventControl: 'no_globalout' | 'only_globalout';
+    zrByTouch: boolean;
+};
+export declare type ZRRawMouseEvent = MouseEvent & ZREventProperties;
+export declare type ZRRawTouchEvent = TouchEvent & ZREventProperties;
+export declare type ZRRawPointerEvent = TouchEvent & ZREventProperties;
+export declare type ZRRawEvent = ZRRawMouseEvent | ZRRawTouchEvent | ZRRawPointerEvent;
+export declare type ZRPinchEvent = ZRRawEvent & {
+    pinchScale: number;
+    pinchX: number;
+    pinchY: number;
+    gestureEvent: string;
+};
+export declare type ElementEventName = 'click' | 'dblclick' | 'mousewheel' | 'mouseout' | 'mouseover' | 'mouseup' | 'mousedown' | 'mousemove' | 'contextmenu' | 'drag' | 'dragstart' | 'dragend' | 'dragenter' | 'dragleave' | 'dragover' | 'drop' | 'globalout';
+export declare type ElementEventNameWithOn = 'onclick' | 'ondblclick' | 'onmousewheel' | 'onmouseout' | 'onmouseup' | 'onmousedown' | 'onmousemove' | 'oncontextmenu' | 'ondrag' | 'ondragstart' | 'ondragend' | 'ondragenter' | 'ondragleave' | 'ondragover' | 'ondrop';
+export declare type RenderedEvent = {
+    elapsedTime: number;
+};
+export declare type PropType<TObj, TProp extends keyof TObj> = TObj[TProp];
+export declare type AllPropTypes<T> = PropType<T, keyof T>;
+export declare type FunctionPropertyNames<T> = {
+    [K in keyof T]: T[K] extends Function ? K : never;
+}[keyof T];
+export declare type MapToType<T extends Dictionary<any>, S> = {
+    [P in keyof T]: T[P] extends Dictionary<any> ? MapToType<T[P], S> : S;
+};
+export declare type KeyOfDistributive<T> = T extends unknown ? keyof T : never;
+export declare type WithThisType<Func extends (...args: any) => any, This> = (this: This, ...args: Parameters<Func>) => ReturnType<Func>;
+export {};

uni-demo/node_modules/zrender/lib/core/types.js

@@ -0,0 +1 @@
+export {};

uni-demo/node_modules/zrender/lib/core/util.d.ts

@@ -0,0 +1,92 @@
+import { Dictionary, ArrayLike, KeyOfDistributive } from './types';
+import { GradientObject } from '../graphic/Gradient';
+import { ImagePatternObject } from '../graphic/Pattern';
+declare const nativeSlice: (start?: number, end?: number) => any[];
+export declare function guid(): number;
+export declare function logError(...args: any[]): void;
+export declare function clone<T extends any>(source: T): T;
+export declare function merge<T extends Dictionary<any>, S extends Dictionary<any>>(target: T, source: S, overwrite?: boolean): T & S;
+export declare function merge<T extends any, S extends any>(target: T, source: S, overwrite?: boolean): T | S;
+export declare function mergeAll(targetAndSources: any[], overwrite?: boolean): any;
+export declare function extend<T extends Dictionary<any>, S extends Dictionary<any>>(target: T, source: S): T & S;
+export declare function defaults<T extends Dictionary<any>, S extends Dictionary<any>>(target: T, source: S, overlay?: boolean): T & S;
+export declare const createCanvas: () => HTMLCanvasElement;
+export declare function indexOf<T>(array: T[] | readonly T[] | ArrayLike<T>, value: T): number;
+export declare function inherits(clazz: Function, baseClazz: Function): void;
+export declare function mixin<T, S>(target: T | Function, source: S | Function, override?: boolean): void;
+export declare function isArrayLike(data: any): data is ArrayLike<any>;
+export declare function each<I extends Dictionary<any> | any[] | readonly any[] | ArrayLike<any>, Context>(arr: I, cb: (this: Context, value: I extends (infer T)[] | readonly (infer T)[] | ArrayLike<infer T> ? T : I extends Dictionary<any> ? I extends Record<infer K, infer T> ? T : unknown : unknown, index?: I extends any[] | readonly any[] | ArrayLike<any> ? number : keyof I & string, arr?: I) => void, context?: Context): void;
+export declare function map<T, R, Context>(arr: readonly T[], cb: (this: Context, val: T, index?: number, arr?: readonly T[]) => R, context?: Context): R[];
+export declare function reduce<T, S, Context>(arr: readonly T[], cb: (this: Context, previousValue: S, currentValue: T, currentIndex?: number, arr?: readonly T[]) => S, memo?: S, context?: Context): S;
+export declare function filter<T, Context>(arr: readonly T[], cb: (this: Context, value: T, index: number, arr: readonly T[]) => boolean, context?: Context): T[];
+export declare function find<T, Context>(arr: readonly T[], cb: (this: Context, value: T, index?: number, arr?: readonly T[]) => boolean, context?: Context): T;
+export declare function keys<T extends object>(obj: T): (KeyOfDistributive<T> & string)[];
+export declare type Bind1<F, Ctx> = F extends (this: Ctx, ...args: infer A) => infer R ? (...args: A) => R : unknown;
+export declare type Bind2<F, Ctx, T1> = F extends (this: Ctx, a: T1, ...args: infer A) => infer R ? (...args: A) => R : unknown;
+export declare type Bind3<F, Ctx, T1, T2> = F extends (this: Ctx, a: T1, b: T2, ...args: infer A) => infer R ? (...args: A) => R : unknown;
+export declare type Bind4<F, Ctx, T1, T2, T3> = F extends (this: Ctx, a: T1, b: T2, c: T3, ...args: infer A) => infer R ? (...args: A) => R : unknown;
+export declare type Bind5<F, Ctx, T1, T2, T3, T4> = F extends (this: Ctx, a: T1, b: T2, c: T3, d: T4, ...args: infer A) => infer R ? (...args: A) => R : unknown;
+declare type BindFunc<Ctx> = (this: Ctx, ...arg: any[]) => any;
+interface FunctionBind {
+    <F extends BindFunc<Ctx>, Ctx>(func: F, ctx: Ctx): Bind1<F, Ctx>;
+    <F extends BindFunc<Ctx>, Ctx, T1 extends Parameters<F>[0]>(func: F, ctx: Ctx, a: T1): Bind2<F, Ctx, T1>;
+    <F extends BindFunc<Ctx>, Ctx, T1 extends Parameters<F>[0], T2 extends Parameters<F>[1]>(func: F, ctx: Ctx, a: T1, b: T2): Bind3<F, Ctx, T1, T2>;
+    <F extends BindFunc<Ctx>, Ctx, T1 extends Parameters<F>[0], T2 extends Parameters<F>[1], T3 extends Parameters<F>[2]>(func: F, ctx: Ctx, a: T1, b: T2, c: T3): Bind4<F, Ctx, T1, T2, T3>;
+    <F extends BindFunc<Ctx>, Ctx, T1 extends Parameters<F>[0], T2 extends Parameters<F>[1], T3 extends Parameters<F>[2], T4 extends Parameters<F>[3]>(func: F, ctx: Ctx, a: T1, b: T2, c: T3, d: T4): Bind5<F, Ctx, T1, T2, T3, T4>;
+}
+export declare const bind: FunctionBind;
+export declare type Curry1<F, T1> = F extends (a: T1, ...args: infer A) => infer R ? (...args: A) => R : unknown;
+export declare type Curry2<F, T1, T2> = F extends (a: T1, b: T2, ...args: infer A) => infer R ? (...args: A) => R : unknown;
+export declare type Curry3<F, T1, T2, T3> = F extends (a: T1, b: T2, c: T3, ...args: infer A) => infer R ? (...args: A) => R : unknown;
+export declare type Curry4<F, T1, T2, T3, T4> = F extends (a: T1, b: T2, c: T3, d: T4, ...args: infer A) => infer R ? (...args: A) => R : unknown;
+declare type CurryFunc = (...arg: any[]) => any;
+declare function curry<F extends CurryFunc, T1 extends Parameters<F>[0]>(func: F, a: T1): Curry1<F, T1>;
+declare function curry<F extends CurryFunc, T1 extends Parameters<F>[0], T2 extends Parameters<F>[1]>(func: F, a: T1, b: T2): Curry2<F, T1, T2>;
+declare function curry<F extends CurryFunc, T1 extends Parameters<F>[0], T2 extends Parameters<F>[1], T3 extends Parameters<F>[2]>(func: F, a: T1, b: T2, c: T3): Curry3<F, T1, T2, T3>;
+declare function curry<F extends CurryFunc, T1 extends Parameters<F>[0], T2 extends Parameters<F>[1], T3 extends Parameters<F>[2], T4 extends Parameters<F>[3]>(func: F, a: T1, b: T2, c: T3, d: T4): Curry4<F, T1, T2, T3, T4>;
+export { curry };
+export declare function isArray(value: any): value is any[];
+export declare function isFunction(value: any): value is Function;
+export declare function isString(value: any): value is string;
+export declare function isStringSafe(value: any): value is string;
+export declare function isNumber(value: any): value is number;
+export declare function isObject<T = unknown>(value: T): value is (object & T);
+export declare function isBuiltInObject(value: any): boolean;
+export declare function isTypedArray(value: any): boolean;
+export declare function isDom(value: any): value is HTMLElement;
+export declare function isGradientObject(value: any): value is GradientObject;
+export declare function isImagePatternObject(value: any): value is ImagePatternObject;
+export declare function isRegExp(value: unknown): value is RegExp;
+export declare function eqNaN(value: any): boolean;
+export declare function retrieve<T>(...args: T[]): T;
+export declare function retrieve2<T, R>(value0: T, value1: R): T | R;
+export declare function retrieve3<T, R, W>(value0: T, value1: R, value2: W): T | R | W;
+declare type SliceParams = Parameters<typeof nativeSlice>;
+export declare function slice<T>(arr: ArrayLike<T>, ...args: SliceParams): T[];
+export declare function normalizeCssArray(val: number | number[]): number[];
+export declare function assert(condition: any, message?: string): void;
+export declare function trim(str: string): string;
+export declare function setAsPrimitive(obj: any): void;
+export declare function isPrimitive(obj: any): boolean;
+export declare class HashMap<T, KEY extends string | number = string | number> {
+    data: {
+        [key in KEY]: T;
+    };
+    constructor(obj?: HashMap<T, KEY> | {
+        [key in KEY]?: T;
+    } | KEY[]);
+    get(key: KEY): T;
+    set(key: KEY, value: T): T;
+    each<Context>(cb: (this: Context, value?: T, key?: KEY) => void, context?: Context): void;
+    keys(): KEY[];
+    removeKey(key: KEY): void;
+}
+export declare function createHashMap<T, KEY extends string | number = string | number>(obj?: HashMap<T, KEY> | {
+    [key in KEY]?: T;
+} | KEY[]): HashMap<T, KEY>;
+export declare function concatArray<T, R>(a: ArrayLike<T>, b: ArrayLike<R>): ArrayLike<T | R>;
+export declare function createObject<T>(proto?: object, properties?: T): T;
+export declare function disableUserSelect(dom: HTMLElement): void;
+export declare function hasOwn(own: object, prop: string): boolean;
+export declare function noop(): void;
+export declare const RADIAN_TO_DEGREE: number;

uni-demo/node_modules/zrender/lib/core/util.js

@@ -0,0 +1,500 @@
+import { platformApi } from './platform.js';
+var BUILTIN_OBJECT = reduce([
+    'Function',
+    'RegExp',
+    'Date',
+    'Error',
+    'CanvasGradient',
+    'CanvasPattern',
+    'Image',
+    'Canvas'
+], function (obj, val) {
+    obj['[object ' + val + ']'] = true;
+    return obj;
+}, {});
+var TYPED_ARRAY = reduce([
+    'Int8',
+    'Uint8',
+    'Uint8Clamped',
+    'Int16',
+    'Uint16',
+    'Int32',
+    'Uint32',
+    'Float32',
+    'Float64'
+], function (obj, val) {
+    obj['[object ' + val + 'Array]'] = true;
+    return obj;
+}, {});
+var objToString = Object.prototype.toString;
+var arrayProto = Array.prototype;
+var nativeForEach = arrayProto.forEach;
+var nativeFilter = arrayProto.filter;
+var nativeSlice = arrayProto.slice;
+var nativeMap = arrayProto.map;
+var ctorFunction = function () { }.constructor;
+var protoFunction = ctorFunction ? ctorFunction.prototype : null;
+var protoKey = '__proto__';
+var idStart = 0x0907;
+export function guid() {
+    return idStart++;
+}
+export function logError() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    if (typeof console !== 'undefined') {
+        console.error.apply(console, args);
+    }
+}
+export function clone(source) {
+    if (source == null || typeof source !== 'object') {
+        return source;
+    }
+    var result = source;
+    var typeStr = objToString.call(source);
+    if (typeStr === '[object Array]') {
+        if (!isPrimitive(source)) {
+            result = [];
+            for (var i = 0, len = source.length; i < len; i++) {
+                result[i] = clone(source[i]);
+            }
+        }
+    }
+    else if (TYPED_ARRAY[typeStr]) {
+        if (!isPrimitive(source)) {
+            var Ctor = source.constructor;
+            if (Ctor.from) {
+                result = Ctor.from(source);
+            }
+            else {
+                result = new Ctor(source.length);
+                for (var i = 0, len = source.length; i < len; i++) {
+                    result[i] = source[i];
+                }
+            }
+        }
+    }
+    else if (!BUILTIN_OBJECT[typeStr] && !isPrimitive(source) && !isDom(source)) {
+        result = {};
+        for (var key in source) {
+            if (source.hasOwnProperty(key) && key !== protoKey) {
+                result[key] = clone(source[key]);
+            }
+        }
+    }
+    return result;
+}
+export function merge(target, source, overwrite) {
+    if (!isObject(source) || !isObject(target)) {
+        return overwrite ? clone(source) : target;
+    }
+    for (var key in source) {
+        if (source.hasOwnProperty(key) && key !== protoKey) {
+            var targetProp = target[key];
+            var sourceProp = source[key];
+            if (isObject(sourceProp)
+                && isObject(targetProp)
+                && !isArray(sourceProp)
+                && !isArray(targetProp)
+                && !isDom(sourceProp)
+                && !isDom(targetProp)
+                && !isBuiltInObject(sourceProp)
+                && !isBuiltInObject(targetProp)
+                && !isPrimitive(sourceProp)
+                && !isPrimitive(targetProp)) {
+                merge(targetProp, sourceProp, overwrite);
+            }
+            else if (overwrite || !(key in target)) {
+                target[key] = clone(source[key]);
+            }
+        }
+    }
+    return target;
+}
+export function mergeAll(targetAndSources, overwrite) {
+    var result = targetAndSources[0];
+    for (var i = 1, len = targetAndSources.length; i < len; i++) {
+        result = merge(result, targetAndSources[i], overwrite);
+    }
+    return result;
+}
+export function extend(target, source) {
+    if (Object.assign) {
+        Object.assign(target, source);
+    }
+    else {
+        for (var key in source) {
+            if (source.hasOwnProperty(key) && key !== protoKey) {
+                target[key] = source[key];
+            }
+        }
+    }
+    return target;
+}
+export function defaults(target, source, overlay) {
+    var keysArr = keys(source);
+    for (var i = 0; i < keysArr.length; i++) {
+        var key = keysArr[i];
+        if ((overlay ? source[key] != null : target[key] == null)) {
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+export var createCanvas = platformApi.createCanvas;
+export function indexOf(array, value) {
+    if (array) {
+        if (array.indexOf) {
+            return array.indexOf(value);
+        }
+        for (var i = 0, len = array.length; i < len; i++) {
+            if (array[i] === value) {
+                return i;
+            }
+        }
+    }
+    return -1;
+}
+export function inherits(clazz, baseClazz) {
+    var clazzPrototype = clazz.prototype;
+    function F() { }
+    F.prototype = baseClazz.prototype;
+    clazz.prototype = new F();
+    for (var prop in clazzPrototype) {
+        if (clazzPrototype.hasOwnProperty(prop)) {
+            clazz.prototype[prop] = clazzPrototype[prop];
+        }
+    }
+    clazz.prototype.constructor = clazz;
+    clazz.superClass = baseClazz;
+}
+export function mixin(target, source, override) {
+    target = 'prototype' in target ? target.prototype : target;
+    source = 'prototype' in source ? source.prototype : source;
+    if (Object.getOwnPropertyNames) {
+        var keyList = Object.getOwnPropertyNames(source);
+        for (var i = 0; i < keyList.length; i++) {
+            var key = keyList[i];
+            if (key !== 'constructor') {
+                if ((override ? source[key] != null : target[key] == null)) {
+                    target[key] = source[key];
+                }
+            }
+        }
+    }
+    else {
+        defaults(target, source, override);
+    }
+}
+export function isArrayLike(data) {
+    if (!data) {
+        return false;
+    }
+    if (typeof data === 'string') {
+        return false;
+    }
+    return typeof data.length === 'number';
+}
+export function each(arr, cb, context) {
+    if (!(arr && cb)) {
+        return;
+    }
+    if (arr.forEach && arr.forEach === nativeForEach) {
+        arr.forEach(cb, context);
+    }
+    else if (arr.length === +arr.length) {
+        for (var i = 0, len = arr.length; i < len; i++) {
+            cb.call(context, arr[i], i, arr);
+        }
+    }
+    else {
+        for (var key in arr) {
+            if (arr.hasOwnProperty(key)) {
+                cb.call(context, arr[key], key, arr);
+            }
+        }
+    }
+}
+export function map(arr, cb, context) {
+    if (!arr) {
+        return [];
+    }
+    if (!cb) {
+        return slice(arr);
+    }
+    if (arr.map && arr.map === nativeMap) {
+        return arr.map(cb, context);
+    }
+    else {
+        var result = [];
+        for (var i = 0, len = arr.length; i < len; i++) {
+            result.push(cb.call(context, arr[i], i, arr));
+        }
+        return result;
+    }
+}
+export function reduce(arr, cb, memo, context) {
+    if (!(arr && cb)) {
+        return;
+    }
+    for (var i = 0, len = arr.length; i < len; i++) {
+        memo = cb.call(context, memo, arr[i], i, arr);
+    }
+    return memo;
+}
+export function filter(arr, cb, context) {
+    if (!arr) {
+        return [];
+    }
+    if (!cb) {
+        return slice(arr);
+    }
+    if (arr.filter && arr.filter === nativeFilter) {
+        return arr.filter(cb, context);
+    }
+    else {
+        var result = [];
+        for (var i = 0, len = arr.length; i < len; i++) {
+            if (cb.call(context, arr[i], i, arr)) {
+                result.push(arr[i]);
+            }
+        }
+        return result;
+    }
+}
+export function find(arr, cb, context) {
+    if (!(arr && cb)) {
+        return;
+    }
+    for (var i = 0, len = arr.length; i < len; i++) {
+        if (cb.call(context, arr[i], i, arr)) {
+            return arr[i];
+        }
+    }
+}
+export function keys(obj) {
+    if (!obj) {
+        return [];
+    }
+    if (Object.keys) {
+        return Object.keys(obj);
+    }
+    var keyList = [];
+    for (var key in obj) {
+        if (obj.hasOwnProperty(key)) {
+            keyList.push(key);
+        }
+    }
+    return keyList;
+}
+function bindPolyfill(func, context) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return function () {
+        return func.apply(context, args.concat(nativeSlice.call(arguments)));
+    };
+}
+export var bind = (protoFunction && isFunction(protoFunction.bind))
+    ? protoFunction.call.bind(protoFunction.bind)
+    : bindPolyfill;
+function curry(func) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    return function () {
+        return func.apply(this, args.concat(nativeSlice.call(arguments)));
+    };
+}
+export { curry };
+export function isArray(value) {
+    if (Array.isArray) {
+        return Array.isArray(value);
+    }
+    return objToString.call(value) === '[object Array]';
+}
+export function isFunction(value) {
+    return typeof value === 'function';
+}
+export function isString(value) {
+    return typeof value === 'string';
+}
+export function isStringSafe(value) {
+    return objToString.call(value) === '[object String]';
+}
+export function isNumber(value) {
+    return typeof value === 'number';
+}
+export function isObject(value) {
+    var type = typeof value;
+    return type === 'function' || (!!value && type === 'object');
+}
+export function isBuiltInObject(value) {
+    return !!BUILTIN_OBJECT[objToString.call(value)];
+}
+export function isTypedArray(value) {
+    return !!TYPED_ARRAY[objToString.call(value)];
+}
+export function isDom(value) {
+    return typeof value === 'object'
+        && typeof value.nodeType === 'number'
+        && typeof value.ownerDocument === 'object';
+}
+export function isGradientObject(value) {
+    return value.colorStops != null;
+}
+export function isImagePatternObject(value) {
+    return value.image != null;
+}
+export function isRegExp(value) {
+    return objToString.call(value) === '[object RegExp]';
+}
+export function eqNaN(value) {
+    return value !== value;
+}
+export function retrieve() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    for (var i = 0, len = args.length; i < len; i++) {
+        if (args[i] != null) {
+            return args[i];
+        }
+    }
+}
+export function retrieve2(value0, value1) {
+    return value0 != null
+        ? value0
+        : value1;
+}
+export function retrieve3(value0, value1, value2) {
+    return value0 != null
+        ? value0
+        : value1 != null
+            ? value1
+            : value2;
+}
+export function slice(arr) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    return nativeSlice.apply(arr, args);
+}
+export function normalizeCssArray(val) {
+    if (typeof (val) === 'number') {
+        return [val, val, val, val];
+    }
+    var len = val.length;
+    if (len === 2) {
+        return [val[0], val[1], val[0], val[1]];
+    }
+    else if (len === 3) {
+        return [val[0], val[1], val[2], val[1]];
+    }
+    return val;
+}
+export function assert(condition, message) {
+    if (!condition) {
+        throw new Error(message);
+    }
+}
+export function trim(str) {
+    if (str == null) {
+        return null;
+    }
+    else if (typeof str.trim === 'function') {
+        return str.trim();
+    }
+    else {
+        return str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
+    }
+}
+var primitiveKey = '__ec_primitive__';
+export function setAsPrimitive(obj) {
+    obj[primitiveKey] = true;
+}
+export function isPrimitive(obj) {
+    return obj[primitiveKey];
+}
+var HashMap = (function () {
+    function HashMap(obj) {
+        this.data = {};
+        var isArr = isArray(obj);
+        this.data = {};
+        var thisMap = this;
+        (obj instanceof HashMap)
+            ? obj.each(visit)
+            : (obj && each(obj, visit));
+        function visit(value, key) {
+            isArr ? thisMap.set(value, key) : thisMap.set(key, value);
+        }
+    }
+    HashMap.prototype.get = function (key) {
+        return this.data.hasOwnProperty(key) ? this.data[key] : null;
+    };
+    HashMap.prototype.set = function (key, value) {
+        return (this.data[key] = value);
+    };
+    HashMap.prototype.each = function (cb, context) {
+        for (var key in this.data) {
+            if (this.data.hasOwnProperty(key)) {
+                cb.call(context, this.data[key], key);
+            }
+        }
+    };
+    HashMap.prototype.keys = function () {
+        return keys(this.data);
+    };
+    HashMap.prototype.removeKey = function (key) {
+        delete this.data[key];
+    };
+    return HashMap;
+}());
+export { HashMap };
+export function createHashMap(obj) {
+    return new HashMap(obj);
+}
+export function concatArray(a, b) {
+    var newArray = new a.constructor(a.length + b.length);
+    for (var i = 0; i < a.length; i++) {
+        newArray[i] = a[i];
+    }
+    var offset = a.length;
+    for (var i = 0; i < b.length; i++) {
+        newArray[i + offset] = b[i];
+    }
+    return newArray;
+}
+export function createObject(proto, properties) {
+    var obj;
+    if (Object.create) {
+        obj = Object.create(proto);
+    }
+    else {
+        var StyleCtor = function () { };
+        StyleCtor.prototype = proto;
+        obj = new StyleCtor();
+    }
+    if (properties) {
+        extend(obj, properties);
+    }
+    return obj;
+}
+export function disableUserSelect(dom) {
+    var domStyle = dom.style;
+    domStyle.webkitUserSelect = 'none';
+    domStyle.userSelect = 'none';
+    domStyle.webkitTapHighlightColor = 'rgba(0,0,0,0)';
+    domStyle['-webkit-touch-callout'] = 'none';
+}
+export function hasOwn(own, prop) {
+    return own.hasOwnProperty(prop);
+}
+export function noop() { }
+export var RADIAN_TO_DEGREE = 180 / Math.PI;

uni-demo/node_modules/zrender/lib/core/vector.d.ts

@@ -0,0 +1,27 @@
+import { MatrixArray } from './matrix';
+export declare type VectorArray = number[];
+export declare function create(x?: number, y?: number): VectorArray;
+export declare function copy<T extends VectorArray>(out: T, v: VectorArray): T;
+export declare function clone(v: VectorArray): VectorArray;
+export declare function set<T extends VectorArray>(out: T, a: number, b: number): T;
+export declare function add<T extends VectorArray>(out: T, v1: VectorArray, v2: VectorArray): T;
+export declare function scaleAndAdd<T extends VectorArray>(out: T, v1: VectorArray, v2: VectorArray, a: number): T;
+export declare function sub<T extends VectorArray>(out: T, v1: VectorArray, v2: VectorArray): T;
+export declare function len(v: VectorArray): number;
+export declare const length: typeof len;
+export declare function lenSquare(v: VectorArray): number;
+export declare const lengthSquare: typeof lenSquare;
+export declare function mul<T extends VectorArray>(out: T, v1: VectorArray, v2: VectorArray): T;
+export declare function div<T extends VectorArray>(out: T, v1: VectorArray, v2: VectorArray): T;
+export declare function dot(v1: VectorArray, v2: VectorArray): number;
+export declare function scale<T extends VectorArray>(out: T, v: VectorArray, s: number): T;
+export declare function normalize<T extends VectorArray>(out: T, v: VectorArray): T;
+export declare function distance(v1: VectorArray, v2: VectorArray): number;
+export declare const dist: typeof distance;
+export declare function distanceSquare(v1: VectorArray, v2: VectorArray): number;
+export declare const distSquare: typeof distanceSquare;
+export declare function negate<T extends VectorArray>(out: T, v: VectorArray): T;
+export declare function lerp<T extends VectorArray>(out: T, v1: VectorArray, v2: VectorArray, t: number): T;
+export declare function applyTransform<T extends VectorArray>(out: T, v: VectorArray, m: MatrixArray): T;
+export declare function min<T extends VectorArray>(out: T, v1: VectorArray, v2: VectorArray): T;
+export declare function max<T extends VectorArray>(out: T, v1: VectorArray, v2: VectorArray): T;

uni-demo/node_modules/zrender/lib/core/vector.js

@@ -0,0 +1,112 @@
+export function create(x, y) {
+    if (x == null) {
+        x = 0;
+    }
+    if (y == null) {
+        y = 0;
+    }
+    return [x, y];
+}
+export function copy(out, v) {
+    out[0] = v[0];
+    out[1] = v[1];
+    return out;
+}
+export function clone(v) {
+    return [v[0], v[1]];
+}
+export function set(out, a, b) {
+    out[0] = a;
+    out[1] = b;
+    return out;
+}
+export function add(out, v1, v2) {
+    out[0] = v1[0] + v2[0];
+    out[1] = v1[1] + v2[1];
+    return out;
+}
+export function scaleAndAdd(out, v1, v2, a) {
+    out[0] = v1[0] + v2[0] * a;
+    out[1] = v1[1] + v2[1] * a;
+    return out;
+}
+export function sub(out, v1, v2) {
+    out[0] = v1[0] - v2[0];
+    out[1] = v1[1] - v2[1];
+    return out;
+}
+export function len(v) {
+    return Math.sqrt(lenSquare(v));
+}
+export var length = len;
+export function lenSquare(v) {
+    return v[0] * v[0] + v[1] * v[1];
+}
+export var lengthSquare = lenSquare;
+export function mul(out, v1, v2) {
+    out[0] = v1[0] * v2[0];
+    out[1] = v1[1] * v2[1];
+    return out;
+}
+export function div(out, v1, v2) {
+    out[0] = v1[0] / v2[0];
+    out[1] = v1[1] / v2[1];
+    return out;
+}
+export function dot(v1, v2) {
+    return v1[0] * v2[0] + v1[1] * v2[1];
+}
+export function scale(out, v, s) {
+    out[0] = v[0] * s;
+    out[1] = v[1] * s;
+    return out;
+}
+export function normalize(out, v) {
+    var d = len(v);
+    if (d === 0) {
+        out[0] = 0;
+        out[1] = 0;
+    }
+    else {
+        out[0] = v[0] / d;
+        out[1] = v[1] / d;
+    }
+    return out;
+}
+export function distance(v1, v2) {
+    return Math.sqrt((v1[0] - v2[0]) * (v1[0] - v2[0])
+        + (v1[1] - v2[1]) * (v1[1] - v2[1]));
+}
+export var dist = distance;
+export function distanceSquare(v1, v2) {
+    return (v1[0] - v2[0]) * (v1[0] - v2[0])
+        + (v1[1] - v2[1]) * (v1[1] - v2[1]);
+}
+export var distSquare = distanceSquare;
+export function negate(out, v) {
+    out[0] = -v[0];
+    out[1] = -v[1];
+    return out;
+}
+export function lerp(out, v1, v2, t) {
+    out[0] = v1[0] + t * (v2[0] - v1[0]);
+    out[1] = v1[1] + t * (v2[1] - v1[1]);
+    return out;
+}
+export function applyTransform(out, v, m) {
+    var x = v[0];
+    var y = v[1];
+    out[0] = m[0] * x + m[2] * y + m[4];
+    out[1] = m[1] * x + m[3] * y + m[5];
+    return out;
+}
+export function min(out, v1, v2) {
+    out[0] = Math.min(v1[0], v2[0]);
+    out[1] = Math.min(v1[1], v2[1]);
+    return out;
+}
+export function max(out, v1, v2) {
+    out[0] = Math.max(v1[0], v2[0]);
+    out[1] = Math.max(v1[1], v2[1]);
+    return out;
+}