push the uni-demo project

uni-demo/node_modules/zrender/lib/Element.d.ts

@@ -0,0 +1,205 @@
+import Transformable, { TransformProp } from './core/Transformable';
+import { AnimationEasing } from './animation/easing';
+import Animator from './animation/Animator';
+import { ZRenderType } from './zrender';
+import { Dictionary, ElementEventName, ZRRawEvent, BuiltinTextPosition, MapToType } from './core/types';
+import Path from './graphic/Path';
+import BoundingRect, { RectLike } from './core/BoundingRect';
+import Eventful from './core/Eventful';
+import ZRText from './graphic/Text';
+import { TextPositionCalculationResult } from './contain/text';
+import Polyline from './graphic/shape/Polyline';
+import Group from './graphic/Group';
+import Point from './core/Point';
+export interface ElementAnimateConfig {
+    duration?: number;
+    delay?: number;
+    easing?: AnimationEasing;
+    during?: (percent: number) => void;
+    done?: Function;
+    aborted?: Function;
+    scope?: string;
+    force?: boolean;
+    additive?: boolean;
+    setToFinal?: boolean;
+}
+export interface ElementTextConfig {
+    position?: BuiltinTextPosition | (number | string)[];
+    rotation?: number;
+    layoutRect?: RectLike;
+    offset?: number[];
+    origin?: (number | string)[] | 'center';
+    distance?: number;
+    local?: boolean;
+    insideFill?: string;
+    insideStroke?: string;
+    outsideFill?: string;
+    outsideStroke?: string;
+    inside?: boolean;
+}
+export interface ElementTextGuideLineConfig {
+    anchor?: Point;
+    showAbove?: boolean;
+    candidates?: ('left' | 'top' | 'right' | 'bottom')[];
+}
+export interface ElementEvent {
+    type: ElementEventName;
+    event: ZRRawEvent;
+    target: Element;
+    topTarget: Element;
+    cancelBubble: boolean;
+    offsetX: number;
+    offsetY: number;
+    gestureEvent: string;
+    pinchX: number;
+    pinchY: number;
+    pinchScale: number;
+    wheelDelta: number;
+    zrByTouch: boolean;
+    which: number;
+    stop: (this: ElementEvent) => void;
+}
+export declare type ElementEventCallback<Ctx, Impl> = (this: CbThis<Ctx, Impl>, e: ElementEvent) => boolean | void;
+declare type CbThis<Ctx, Impl> = unknown extends Ctx ? Impl : Ctx;
+interface ElementEventHandlerProps {
+    onclick: ElementEventCallback<unknown, unknown>;
+    ondblclick: ElementEventCallback<unknown, unknown>;
+    onmouseover: ElementEventCallback<unknown, unknown>;
+    onmouseout: ElementEventCallback<unknown, unknown>;
+    onmousemove: ElementEventCallback<unknown, unknown>;
+    onmousewheel: ElementEventCallback<unknown, unknown>;
+    onmousedown: ElementEventCallback<unknown, unknown>;
+    onmouseup: ElementEventCallback<unknown, unknown>;
+    oncontextmenu: ElementEventCallback<unknown, unknown>;
+    ondrag: ElementEventCallback<unknown, unknown>;
+    ondragstart: ElementEventCallback<unknown, unknown>;
+    ondragend: ElementEventCallback<unknown, unknown>;
+    ondragenter: ElementEventCallback<unknown, unknown>;
+    ondragleave: ElementEventCallback<unknown, unknown>;
+    ondragover: ElementEventCallback<unknown, unknown>;
+    ondrop: ElementEventCallback<unknown, unknown>;
+}
+export interface ElementProps extends Partial<ElementEventHandlerProps>, Partial<Pick<Transformable, TransformProp>> {
+    name?: string;
+    ignore?: boolean;
+    isGroup?: boolean;
+    draggable?: boolean | 'horizontal' | 'vertical';
+    silent?: boolean;
+    ignoreClip?: boolean;
+    globalScaleRatio?: number;
+    textConfig?: ElementTextConfig;
+    textContent?: ZRText;
+    clipPath?: Path;
+    drift?: Element['drift'];
+    extra?: Dictionary<unknown>;
+    anid?: string;
+}
+export declare const PRESERVED_NORMAL_STATE = "__zr_normal__";
+declare const PRIMARY_STATES_KEYS: ["x" | "y" | "originX" | "originY" | "anchorX" | "anchorY" | "rotation" | "scaleX" | "scaleY" | "skewX" | "skewY", "ignore"];
+export declare type ElementStatePropNames = (typeof PRIMARY_STATES_KEYS)[number] | 'textConfig';
+export declare type ElementState = Pick<ElementProps, ElementStatePropNames> & ElementCommonState;
+export declare type ElementCommonState = {
+    hoverLayer?: boolean;
+};
+export declare type ElementCalculateTextPosition = (out: TextPositionCalculationResult, style: ElementTextConfig, rect: RectLike) => TextPositionCalculationResult;
+interface Element<Props extends ElementProps = ElementProps> extends Transformable, Eventful<{
+    [key in ElementEventName]: (e: ElementEvent) => void | boolean;
+} & {
+    [key in string]: (...args: any) => void | boolean;
+}>, ElementEventHandlerProps {
+}
+declare class Element<Props extends ElementProps = ElementProps> {
+    id: number;
+    type: string;
+    name: string;
+    ignore: boolean;
+    silent: boolean;
+    isGroup: boolean;
+    draggable: boolean | 'horizontal' | 'vertical';
+    dragging: boolean;
+    parent: Group;
+    animators: Animator<any>[];
+    ignoreClip: boolean;
+    __hostTarget: Element;
+    __zr: ZRenderType;
+    __dirty: number;
+    __isRendered: boolean;
+    __inHover: boolean;
+    private _clipPath?;
+    private _textContent?;
+    private _textGuide?;
+    textConfig?: ElementTextConfig;
+    textGuideLineConfig?: ElementTextGuideLineConfig;
+    anid: string;
+    extra: Dictionary<unknown>;
+    currentStates?: string[];
+    prevStates?: string[];
+    states: Dictionary<ElementState>;
+    stateTransition: ElementAnimateConfig;
+    stateProxy?: (stateName: string, targetStates?: string[]) => ElementState;
+    protected _normalState: ElementState;
+    private _innerTextDefaultStyle;
+    constructor(props?: Props);
+    protected _init(props?: Props): void;
+    drift(dx: number, dy: number, e?: ElementEvent): void;
+    beforeUpdate(): void;
+    afterUpdate(): void;
+    update(): void;
+    updateInnerText(forceUpdate?: boolean): void;
+    protected canBeInsideText(): boolean;
+    protected getInsideTextFill(): string | undefined;
+    protected getInsideTextStroke(textFill: string): string | undefined;
+    protected getOutsideFill(): string | undefined;
+    protected getOutsideStroke(textFill: string): string;
+    traverse<Context>(cb: (this: Context, el: Element<Props>) => void, context?: Context): void;
+    protected attrKV(key: string, value: unknown): void;
+    hide(): void;
+    show(): void;
+    attr(keyOrObj: Props): this;
+    attr<T extends keyof Props>(keyOrObj: T, value: Props[T]): this;
+    saveCurrentToNormalState(toState: ElementState): void;
+    protected _innerSaveToNormal(toState: ElementState): void;
+    protected _savePrimaryToNormal(toState: Dictionary<any>, normalState: Dictionary<any>, primaryKeys: readonly string[]): void;
+    hasState(): boolean;
+    getState(name: string): ElementState;
+    ensureState(name: string): ElementState;
+    clearStates(noAnimation?: boolean): void;
+    useState(stateName: string, keepCurrentStates?: boolean, noAnimation?: boolean, forceUseHoverLayer?: boolean): ElementState;
+    useStates(states: string[], noAnimation?: boolean, forceUseHoverLayer?: boolean): void;
+    private _updateAnimationTargets;
+    removeState(state: string): void;
+    replaceState(oldState: string, newState: string, forceAdd: boolean): void;
+    toggleState(state: string, enable: boolean): void;
+    protected _mergeStates(states: ElementState[]): ElementState;
+    protected _applyStateObj(stateName: string, state: ElementState, normalState: ElementState, keepCurrentStates: boolean, transition: boolean, animationCfg: ElementAnimateConfig): void;
+    private _attachComponent;
+    private _detachComponent;
+    getClipPath(): Path<import("./graphic/Path").PathProps>;
+    setClipPath(clipPath: Path): void;
+    removeClipPath(): void;
+    getTextContent(): ZRText;
+    setTextContent(textEl: ZRText): void;
+    setTextConfig(cfg: ElementTextConfig): void;
+    removeTextConfig(): void;
+    removeTextContent(): void;
+    getTextGuideLine(): Polyline;
+    setTextGuideLine(guideLine: Polyline): void;
+    removeTextGuideLine(): void;
+    markRedraw(): void;
+    dirty(): void;
+    private _toggleHoverLayerFlag;
+    addSelfToZr(zr: ZRenderType): void;
+    removeSelfFromZr(zr: ZRenderType): void;
+    animate(key?: string, loop?: boolean, allowDiscreteAnimation?: boolean): Animator<any>;
+    addAnimator(animator: Animator<any>, key: string): void;
+    updateDuringAnimation(key: string): void;
+    stopAnimation(scope?: string, forwardToLast?: boolean): this;
+    animateTo(target: Props, cfg?: ElementAnimateConfig, animationProps?: MapToType<Props, boolean>): void;
+    animateFrom(target: Props, cfg: ElementAnimateConfig, animationProps?: MapToType<Props, boolean>): void;
+    protected _transitionState(stateName: string, target: Props, cfg?: ElementAnimateConfig, animationProps?: MapToType<Props, boolean>): void;
+    getBoundingRect(): BoundingRect;
+    getPaintRect(): BoundingRect;
+    calculateTextPosition: ElementCalculateTextPosition;
+    protected static initDefaultProps: void;
+}
+export default Element;

uni-demo/node_modules/zrender/lib/Handler.d.ts

@@ -0,0 +1,48 @@
+import Eventful from './core/Eventful';
+import Displayable from './graphic/Displayable';
+import { PainterBase } from './PainterBase';
+import { HandlerProxyInterface } from './dom/HandlerProxy';
+import { ZRRawEvent, ElementEventName } from './core/types';
+import Storage from './Storage';
+import Element from './Element';
+declare class HoveredResult {
+    x: number;
+    y: number;
+    target: Displayable;
+    topTarget: Displayable;
+    constructor(x?: number, y?: number);
+}
+declare type HandlerName = 'click' | 'dblclick' | 'mousewheel' | 'mouseout' | 'mouseup' | 'mousedown' | 'mousemove' | 'contextmenu';
+declare class Handler extends Eventful {
+    storage: Storage;
+    painter: PainterBase;
+    painterRoot: HTMLElement;
+    proxy: HandlerProxyInterface;
+    private _hovered;
+    private _gestureMgr;
+    private _draggingMgr;
+    _downEl: Element;
+    _upEl: Element;
+    _downPoint: [number, number];
+    constructor(storage: Storage, painter: PainterBase, proxy: HandlerProxyInterface, painterRoot: HTMLElement);
+    setHandlerProxy(proxy: HandlerProxyInterface): void;
+    mousemove(event: ZRRawEvent): void;
+    mouseout(event: ZRRawEvent): void;
+    resize(): void;
+    dispatch(eventName: HandlerName, eventArgs?: any): void;
+    dispose(): void;
+    setCursorStyle(cursorStyle: string): void;
+    dispatchToElement(targetInfo: {
+        target?: Element;
+        topTarget?: Element;
+    }, eventName: ElementEventName, event: ZRRawEvent): void;
+    findHover(x: number, y: number, exclude?: Displayable): HoveredResult;
+    processGesture(event: ZRRawEvent, stage?: 'start' | 'end' | 'change'): void;
+    click: (event: ZRRawEvent) => void;
+    mousedown: (event: ZRRawEvent) => void;
+    mouseup: (event: ZRRawEvent) => void;
+    mousewheel: (event: ZRRawEvent) => void;
+    dblclick: (event: ZRRawEvent) => void;
+    contextmenu: (event: ZRRawEvent) => void;
+}
+export default Handler;

uni-demo/node_modules/zrender/lib/Handler.js

@@ -0,0 +1,252 @@
+import { __extends } from "tslib";
+import * as util from './core/util.js';
+import * as vec2 from './core/vector.js';
+import Draggable from './mixin/Draggable.js';
+import Eventful from './core/Eventful.js';
+import * as eventTool from './core/event.js';
+import { GestureMgr } from './core/GestureMgr.js';
+var SILENT = 'silent';
+function makeEventPacket(eveType, targetInfo, event) {
+    return {
+        type: eveType,
+        event: event,
+        target: targetInfo.target,
+        topTarget: targetInfo.topTarget,
+        cancelBubble: false,
+        offsetX: event.zrX,
+        offsetY: event.zrY,
+        gestureEvent: event.gestureEvent,
+        pinchX: event.pinchX,
+        pinchY: event.pinchY,
+        pinchScale: event.pinchScale,
+        wheelDelta: event.zrDelta,
+        zrByTouch: event.zrByTouch,
+        which: event.which,
+        stop: stopEvent
+    };
+}
+function stopEvent() {
+    eventTool.stop(this.event);
+}
+var EmptyProxy = (function (_super) {
+    __extends(EmptyProxy, _super);
+    function EmptyProxy() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.handler = null;
+        return _this;
+    }
+    EmptyProxy.prototype.dispose = function () { };
+    EmptyProxy.prototype.setCursor = function () { };
+    return EmptyProxy;
+}(Eventful));
+var HoveredResult = (function () {
+    function HoveredResult(x, y) {
+        this.x = x;
+        this.y = y;
+    }
+    return HoveredResult;
+}());
+var handlerNames = [
+    'click', 'dblclick', 'mousewheel', 'mouseout',
+    'mouseup', 'mousedown', 'mousemove', 'contextmenu'
+];
+var Handler = (function (_super) {
+    __extends(Handler, _super);
+    function Handler(storage, painter, proxy, painterRoot) {
+        var _this = _super.call(this) || this;
+        _this._hovered = new HoveredResult(0, 0);
+        _this.storage = storage;
+        _this.painter = painter;
+        _this.painterRoot = painterRoot;
+        proxy = proxy || new EmptyProxy();
+        _this.proxy = null;
+        _this.setHandlerProxy(proxy);
+        _this._draggingMgr = new Draggable(_this);
+        return _this;
+    }
+    Handler.prototype.setHandlerProxy = function (proxy) {
+        if (this.proxy) {
+            this.proxy.dispose();
+        }
+        if (proxy) {
+            util.each(handlerNames, function (name) {
+                proxy.on && proxy.on(name, this[name], this);
+            }, this);
+            proxy.handler = this;
+        }
+        this.proxy = proxy;
+    };
+    Handler.prototype.mousemove = function (event) {
+        var x = event.zrX;
+        var y = event.zrY;
+        var isOutside = isOutsideBoundary(this, x, y);
+        var lastHovered = this._hovered;
+        var lastHoveredTarget = lastHovered.target;
+        if (lastHoveredTarget && !lastHoveredTarget.__zr) {
+            lastHovered = this.findHover(lastHovered.x, lastHovered.y);
+            lastHoveredTarget = lastHovered.target;
+        }
+        var hovered = this._hovered = isOutside ? new HoveredResult(x, y) : this.findHover(x, y);
+        var hoveredTarget = hovered.target;
+        var proxy = this.proxy;
+        proxy.setCursor && proxy.setCursor(hoveredTarget ? hoveredTarget.cursor : 'default');
+        if (lastHoveredTarget && hoveredTarget !== lastHoveredTarget) {
+            this.dispatchToElement(lastHovered, 'mouseout', event);
+        }
+        this.dispatchToElement(hovered, 'mousemove', event);
+        if (hoveredTarget && hoveredTarget !== lastHoveredTarget) {
+            this.dispatchToElement(hovered, 'mouseover', event);
+        }
+    };
+    Handler.prototype.mouseout = function (event) {
+        var eventControl = event.zrEventControl;
+        if (eventControl !== 'only_globalout') {
+            this.dispatchToElement(this._hovered, 'mouseout', event);
+        }
+        if (eventControl !== 'no_globalout') {
+            this.trigger('globalout', { type: 'globalout', event: event });
+        }
+    };
+    Handler.prototype.resize = function () {
+        this._hovered = new HoveredResult(0, 0);
+    };
+    Handler.prototype.dispatch = function (eventName, eventArgs) {
+        var handler = this[eventName];
+        handler && handler.call(this, eventArgs);
+    };
+    Handler.prototype.dispose = function () {
+        this.proxy.dispose();
+        this.storage = null;
+        this.proxy = null;
+        this.painter = null;
+    };
+    Handler.prototype.setCursorStyle = function (cursorStyle) {
+        var proxy = this.proxy;
+        proxy.setCursor && proxy.setCursor(cursorStyle);
+    };
+    Handler.prototype.dispatchToElement = function (targetInfo, eventName, event) {
+        targetInfo = targetInfo || {};
+        var el = targetInfo.target;
+        if (el && el.silent) {
+            return;
+        }
+        var eventKey = ('on' + eventName);
+        var eventPacket = makeEventPacket(eventName, targetInfo, event);
+        while (el) {
+            el[eventKey]
+                && (eventPacket.cancelBubble = !!el[eventKey].call(el, eventPacket));
+            el.trigger(eventName, eventPacket);
+            el = el.__hostTarget ? el.__hostTarget : el.parent;
+            if (eventPacket.cancelBubble) {
+                break;
+            }
+        }
+        if (!eventPacket.cancelBubble) {
+            this.trigger(eventName, eventPacket);
+            if (this.painter && this.painter.eachOtherLayer) {
+                this.painter.eachOtherLayer(function (layer) {
+                    if (typeof (layer[eventKey]) === 'function') {
+                        layer[eventKey].call(layer, eventPacket);
+                    }
+                    if (layer.trigger) {
+                        layer.trigger(eventName, eventPacket);
+                    }
+                });
+            }
+        }
+    };
+    Handler.prototype.findHover = function (x, y, exclude) {
+        var list = this.storage.getDisplayList();
+        var out = new HoveredResult(x, y);
+        for (var i = list.length - 1; i >= 0; i--) {
+            var hoverCheckResult = void 0;
+            if (list[i] !== exclude
+                && !list[i].ignore
+                && (hoverCheckResult = isHover(list[i], x, y))) {
+                !out.topTarget && (out.topTarget = list[i]);
+                if (hoverCheckResult !== SILENT) {
+                    out.target = list[i];
+                    break;
+                }
+            }
+        }
+        return out;
+    };
+    Handler.prototype.processGesture = function (event, stage) {
+        if (!this._gestureMgr) {
+            this._gestureMgr = new GestureMgr();
+        }
+        var gestureMgr = this._gestureMgr;
+        stage === 'start' && gestureMgr.clear();
+        var gestureInfo = gestureMgr.recognize(event, this.findHover(event.zrX, event.zrY, null).target, this.proxy.dom);
+        stage === 'end' && gestureMgr.clear();
+        if (gestureInfo) {
+            var type = gestureInfo.type;
+            event.gestureEvent = type;
+            var res = new HoveredResult();
+            res.target = gestureInfo.target;
+            this.dispatchToElement(res, type, gestureInfo.event);
+        }
+    };
+    return Handler;
+}(Eventful));
+util.each(['click', 'mousedown', 'mouseup', 'mousewheel', 'dblclick', 'contextmenu'], function (name) {
+    Handler.prototype[name] = function (event) {
+        var x = event.zrX;
+        var y = event.zrY;
+        var isOutside = isOutsideBoundary(this, x, y);
+        var hovered;
+        var hoveredTarget;
+        if (name !== 'mouseup' || !isOutside) {
+            hovered = this.findHover(x, y);
+            hoveredTarget = hovered.target;
+        }
+        if (name === 'mousedown') {
+            this._downEl = hoveredTarget;
+            this._downPoint = [event.zrX, event.zrY];
+            this._upEl = hoveredTarget;
+        }
+        else if (name === 'mouseup') {
+            this._upEl = hoveredTarget;
+        }
+        else if (name === 'click') {
+            if (this._downEl !== this._upEl
+                || !this._downPoint
+                || vec2.dist(this._downPoint, [event.zrX, event.zrY]) > 4) {
+                return;
+            }
+            this._downPoint = null;
+        }
+        this.dispatchToElement(hovered, name, event);
+    };
+});
+function isHover(displayable, x, y) {
+    if (displayable[displayable.rectHover ? 'rectContain' : 'contain'](x, y)) {
+        var el = displayable;
+        var isSilent = void 0;
+        var ignoreClip = false;
+        while (el) {
+            if (el.ignoreClip) {
+                ignoreClip = true;
+            }
+            if (!ignoreClip) {
+                var clipPath = el.getClipPath();
+                if (clipPath && !clipPath.contain(x, y)) {
+                    return false;
+                }
+                if (el.silent) {
+                    isSilent = true;
+                }
+            }
+            var hostEl = el.__hostTarget;
+            el = hostEl ? hostEl : el.parent;
+        }
+        return isSilent ? SILENT : true;
+    }
+    return false;
+}
+function isOutsideBoundary(handlerInstance, x, y) {
+    var painter = handlerInstance.painter;
+    return x < 0 || x > painter.getWidth() || y < 0 || y > painter.getHeight();
+}
+export default Handler;

uni-demo/node_modules/zrender/lib/PainterBase.d.ts

@@ -0,0 +1,24 @@
+import { GradientObject } from './graphic/Gradient';
+import { PatternObject } from './graphic/Pattern';
+import { Dictionary } from './core/types';
+export interface PainterBase {
+    type: string;
+    root?: HTMLElement;
+    ssrOnly?: boolean;
+    resize(width?: number | string, height?: number | string): void;
+    refresh(): void;
+    clear(): void;
+    renderToString?(): string;
+    getType: () => string;
+    getWidth(): number;
+    getHeight(): number;
+    dispose(): void;
+    getViewportRoot: () => HTMLElement;
+    getViewportRootOffset: () => {
+        offsetLeft: number;
+        offsetTop: number;
+    };
+    refreshHover(): void;
+    configLayer(zlevel: number, config: Dictionary<any>): void;
+    setBackgroundColor(backgroundColor: string | GradientObject | PatternObject): void;
+}

uni-demo/node_modules/zrender/lib/PainterBase.js

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

uni-demo/node_modules/zrender/lib/Storage.d.ts

@@ -0,0 +1,19 @@
+import Element from './Element';
+import Displayable from './graphic/Displayable';
+declare function shapeCompareFunc(a: Displayable, b: Displayable): number;
+export default class Storage {
+    private _roots;
+    private _displayList;
+    private _displayListLen;
+    traverse<T>(cb: (this: T, el: Element) => void, context?: T): void;
+    getDisplayList(update?: boolean, includeIgnore?: boolean): Displayable[];
+    updateDisplayList(includeIgnore?: boolean): void;
+    private _updateAndAddDisplayable;
+    addRoot(el: Element): void;
+    delRoot(el: Element | Element[]): void;
+    delAllRoots(): void;
+    getRoots(): Element<import("./Element").ElementProps>[];
+    dispose(): void;
+    displayableSortFunc: typeof shapeCompareFunc;
+}
+export {};

uni-demo/node_modules/zrender/lib/Storage.js

@@ -0,0 +1,158 @@
+import * as util from './core/util.js';
+import timsort from './core/timsort.js';
+import { REDRAW_BIT } from './graphic/constants.js';
+var invalidZErrorLogged = false;
+function logInvalidZError() {
+    if (invalidZErrorLogged) {
+        return;
+    }
+    invalidZErrorLogged = true;
+    console.warn('z / z2 / zlevel of displayable is invalid, which may cause unexpected errors');
+}
+function shapeCompareFunc(a, b) {
+    if (a.zlevel === b.zlevel) {
+        if (a.z === b.z) {
+            return a.z2 - b.z2;
+        }
+        return a.z - b.z;
+    }
+    return a.zlevel - b.zlevel;
+}
+var Storage = (function () {
+    function Storage() {
+        this._roots = [];
+        this._displayList = [];
+        this._displayListLen = 0;
+        this.displayableSortFunc = shapeCompareFunc;
+    }
+    Storage.prototype.traverse = function (cb, context) {
+        for (var i = 0; i < this._roots.length; i++) {
+            this._roots[i].traverse(cb, context);
+        }
+    };
+    Storage.prototype.getDisplayList = function (update, includeIgnore) {
+        includeIgnore = includeIgnore || false;
+        var displayList = this._displayList;
+        if (update || !displayList.length) {
+            this.updateDisplayList(includeIgnore);
+        }
+        return displayList;
+    };
+    Storage.prototype.updateDisplayList = function (includeIgnore) {
+        this._displayListLen = 0;
+        var roots = this._roots;
+        var displayList = this._displayList;
+        for (var i = 0, len = roots.length; i < len; i++) {
+            this._updateAndAddDisplayable(roots[i], null, includeIgnore);
+        }
+        displayList.length = this._displayListLen;
+        timsort(displayList, shapeCompareFunc);
+    };
+    Storage.prototype._updateAndAddDisplayable = function (el, clipPaths, includeIgnore) {
+        if (el.ignore && !includeIgnore) {
+            return;
+        }
+        el.beforeUpdate();
+        el.update();
+        el.afterUpdate();
+        var userSetClipPath = el.getClipPath();
+        if (el.ignoreClip) {
+            clipPaths = null;
+        }
+        else if (userSetClipPath) {
+            if (clipPaths) {
+                clipPaths = clipPaths.slice();
+            }
+            else {
+                clipPaths = [];
+            }
+            var currentClipPath = userSetClipPath;
+            var parentClipPath = el;
+            while (currentClipPath) {
+                currentClipPath.parent = parentClipPath;
+                currentClipPath.updateTransform();
+                clipPaths.push(currentClipPath);
+                parentClipPath = currentClipPath;
+                currentClipPath = currentClipPath.getClipPath();
+            }
+        }
+        if (el.childrenRef) {
+            var children = el.childrenRef();
+            for (var i = 0; i < children.length; i++) {
+                var child = children[i];
+                if (el.__dirty) {
+                    child.__dirty |= REDRAW_BIT;
+                }
+                this._updateAndAddDisplayable(child, clipPaths, includeIgnore);
+            }
+            el.__dirty = 0;
+        }
+        else {
+            var disp = el;
+            if (clipPaths && clipPaths.length) {
+                disp.__clipPaths = clipPaths;
+            }
+            else if (disp.__clipPaths && disp.__clipPaths.length > 0) {
+                disp.__clipPaths = [];
+            }
+            if (isNaN(disp.z)) {
+                logInvalidZError();
+                disp.z = 0;
+            }
+            if (isNaN(disp.z2)) {
+                logInvalidZError();
+                disp.z2 = 0;
+            }
+            if (isNaN(disp.zlevel)) {
+                logInvalidZError();
+                disp.zlevel = 0;
+            }
+            this._displayList[this._displayListLen++] = disp;
+        }
+        var decalEl = el.getDecalElement && el.getDecalElement();
+        if (decalEl) {
+            this._updateAndAddDisplayable(decalEl, clipPaths, includeIgnore);
+        }
+        var textGuide = el.getTextGuideLine();
+        if (textGuide) {
+            this._updateAndAddDisplayable(textGuide, clipPaths, includeIgnore);
+        }
+        var textEl = el.getTextContent();
+        if (textEl) {
+            this._updateAndAddDisplayable(textEl, clipPaths, includeIgnore);
+        }
+    };
+    Storage.prototype.addRoot = function (el) {
+        if (el.__zr && el.__zr.storage === this) {
+            return;
+        }
+        this._roots.push(el);
+    };
+    Storage.prototype.delRoot = function (el) {
+        if (el instanceof Array) {
+            for (var i = 0, l = el.length; i < l; i++) {
+                this.delRoot(el[i]);
+            }
+            return;
+        }
+        var idx = util.indexOf(this._roots, el);
+        if (idx >= 0) {
+            this._roots.splice(idx, 1);
+        }
+    };
+    Storage.prototype.delAllRoots = function () {
+        this._roots = [];
+        this._displayList = [];
+        this._displayListLen = 0;
+        return;
+    };
+    Storage.prototype.getRoots = function () {
+        return this._roots;
+    };
+    Storage.prototype.dispose = function () {
+        this._displayList = null;
+        this._roots = null;
+    };
+    return Storage;
+}());
+export default Storage;

uni-demo/node_modules/zrender/lib/all.d.ts

@@ -0,0 +1,2 @@
+export * from './zrender';
+export * from './export';

uni-demo/node_modules/zrender/lib/all.js

@@ -0,0 +1,7 @@
+export * from './zrender.js';
+export * from './export.js';
+import { registerPainter } from './zrender.js';
+import CanvasPainter from './canvas/Painter.js';
+import SVGPainter from './svg/Painter.js';
+registerPainter('canvas', CanvasPainter);
+registerPainter('svg', SVGPainter);

uni-demo/node_modules/zrender/lib/animation/Animation.d.ts

@@ -0,0 +1,37 @@
+import Eventful from '../core/Eventful';
+import Animator from './Animator';
+import Clip from './Clip';
+export declare function getTime(): number;
+interface Stage {
+    update?: () => void;
+}
+interface AnimationOption {
+    stage?: Stage;
+}
+export default class Animation extends Eventful {
+    stage: Stage;
+    private _head;
+    private _tail;
+    private _running;
+    private _time;
+    private _pausedTime;
+    private _pauseStart;
+    private _paused;
+    constructor(opts?: AnimationOption);
+    addClip(clip: Clip): void;
+    addAnimator(animator: Animator<any>): void;
+    removeClip(clip: Clip): void;
+    removeAnimator(animator: Animator<any>): void;
+    update(notTriggerFrameAndStageUpdate?: boolean): void;
+    _startLoop(): void;
+    start(): void;
+    stop(): void;
+    pause(): void;
+    resume(): void;
+    clear(): void;
+    isFinished(): boolean;
+    animate<T>(target: T, options: {
+        loop?: boolean;
+    }): Animator<T>;
+}
+export {};

uni-demo/node_modules/zrender/lib/animation/Animation.js

@@ -0,0 +1,147 @@
+import { __extends } from "tslib";
+import Eventful from '../core/Eventful.js';
+import requestAnimationFrame from './requestAnimationFrame.js';
+import Animator from './Animator.js';
+export function getTime() {
+    return new Date().getTime();
+}
+var Animation = (function (_super) {
+    __extends(Animation, _super);
+    function Animation(opts) {
+        var _this = _super.call(this) || this;
+        _this._running = false;
+        _this._time = 0;
+        _this._pausedTime = 0;
+        _this._pauseStart = 0;
+        _this._paused = false;
+        opts = opts || {};
+        _this.stage = opts.stage || {};
+        return _this;
+    }
+    Animation.prototype.addClip = function (clip) {
+        if (clip.animation) {
+            this.removeClip(clip);
+        }
+        if (!this._head) {
+            this._head = this._tail = clip;
+        }
+        else {
+            this._tail.next = clip;
+            clip.prev = this._tail;
+            clip.next = null;
+            this._tail = clip;
+        }
+        clip.animation = this;
+    };
+    Animation.prototype.addAnimator = function (animator) {
+        animator.animation = this;
+        var clip = animator.getClip();
+        if (clip) {
+            this.addClip(clip);
+        }
+    };
+    Animation.prototype.removeClip = function (clip) {
+        if (!clip.animation) {
+            return;
+        }
+        var prev = clip.prev;
+        var next = clip.next;
+        if (prev) {
+            prev.next = next;
+        }
+        else {
+            this._head = next;
+        }
+        if (next) {
+            next.prev = prev;
+        }
+        else {
+            this._tail = prev;
+        }
+        clip.next = clip.prev = clip.animation = null;
+    };
+    Animation.prototype.removeAnimator = function (animator) {
+        var clip = animator.getClip();
+        if (clip) {
+            this.removeClip(clip);
+        }
+        animator.animation = null;
+    };
+    Animation.prototype.update = function (notTriggerFrameAndStageUpdate) {
+        var time = getTime() - this._pausedTime;
+        var delta = time - this._time;
+        var clip = this._head;
+        while (clip) {
+            var nextClip = clip.next;
+            var finished = clip.step(time, delta);
+            if (finished) {
+                clip.ondestroy();
+                this.removeClip(clip);
+                clip = nextClip;
+            }
+            else {
+                clip = nextClip;
+            }
+        }
+        this._time = time;
+        if (!notTriggerFrameAndStageUpdate) {
+            this.trigger('frame', delta);
+            this.stage.update && this.stage.update();
+        }
+    };
+    Animation.prototype._startLoop = function () {
+        var self = this;
+        this._running = true;
+        function step() {
+            if (self._running) {
+                requestAnimationFrame(step);
+                !self._paused && self.update();
+            }
+        }
+        requestAnimationFrame(step);
+    };
+    Animation.prototype.start = function () {
+        if (this._running) {
+            return;
+        }
+        this._time = getTime();
+        this._pausedTime = 0;
+        this._startLoop();
+    };
+    Animation.prototype.stop = function () {
+        this._running = false;
+    };
+    Animation.prototype.pause = function () {
+        if (!this._paused) {
+            this._pauseStart = getTime();
+            this._paused = true;
+        }
+    };
+    Animation.prototype.resume = function () {
+        if (this._paused) {
+            this._pausedTime += getTime() - this._pauseStart;
+            this._paused = false;
+        }
+    };
+    Animation.prototype.clear = function () {
+        var clip = this._head;
+        while (clip) {
+            var nextClip = clip.next;
+            clip.prev = clip.next = clip.animation = null;
+            clip = nextClip;
+        }
+        this._head = this._tail = null;
+    };
+    Animation.prototype.isFinished = function () {
+        return this._head == null;
+    };
+    Animation.prototype.animate = function (target, options) {
+        options = options || {};
+        this.start();
+        var animator = new Animator(target, options.loop);
+        this.addAnimator(animator);
+        return animator;
+    };
+    return Animation;
+}(Eventful));
+export default Animation;

uni-demo/node_modules/zrender/lib/animation/Animator.d.ts

@@ -0,0 +1,95 @@
+import Clip from './Clip';
+import { ArrayLike, Dictionary } from '../core/types';
+import { AnimationEasing } from './easing';
+import Animation from './Animation';
+declare type NumberArray = ArrayLike<number>;
+declare type InterpolatableType = string | number | NumberArray | NumberArray[];
+export declare function cloneValue(value: InterpolatableType): number | any[];
+declare type ValueType = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+declare type Keyframe = {
+    time: number;
+    value: unknown;
+    percent: number;
+    rawValue: unknown;
+    easing?: AnimationEasing;
+    easingFunc?: (percent: number) => number;
+    additiveValue?: unknown;
+};
+declare class Track {
+    keyframes: Keyframe[];
+    propName: string;
+    valType: ValueType;
+    discrete: boolean;
+    _invalid: boolean;
+    private _finished;
+    private _needsSort;
+    private _additiveTrack;
+    private _additiveValue;
+    private _lastFr;
+    private _lastFrP;
+    constructor(propName: string);
+    isFinished(): boolean;
+    setFinished(): void;
+    needsAnimate(): boolean;
+    getAdditiveTrack(): Track;
+    addKeyframe(time: number, rawValue: unknown, easing?: AnimationEasing): Keyframe;
+    prepare(maxTime: number, additiveTrack?: Track): void;
+    step(target: any, percent: number): void;
+    private _addToTarget;
+}
+declare type DoneCallback = () => void;
+declare type AbortCallback = () => void;
+export declare type OnframeCallback<T> = (target: T, percent: number) => void;
+export declare type AnimationPropGetter<T> = (target: T, key: string) => InterpolatableType;
+export declare type AnimationPropSetter<T> = (target: T, key: string, value: InterpolatableType) => void;
+export default class Animator<T> {
+    animation?: Animation;
+    targetName?: string;
+    scope?: string;
+    __fromStateTransition?: string;
+    private _tracks;
+    private _trackKeys;
+    private _target;
+    private _loop;
+    private _delay;
+    private _maxTime;
+    private _force;
+    private _paused;
+    private _started;
+    private _allowDiscrete;
+    private _additiveAnimators;
+    private _doneCbs;
+    private _onframeCbs;
+    private _abortedCbs;
+    private _clip;
+    constructor(target: T, loop: boolean, allowDiscreteAnimation?: boolean, additiveTo?: Animator<any>[]);
+    getMaxTime(): number;
+    getDelay(): number;
+    getLoop(): boolean;
+    getTarget(): T;
+    changeTarget(target: T): void;
+    when(time: number, props: Dictionary<any>, easing?: AnimationEasing): this;
+    whenWithKeys(time: number, props: Dictionary<any>, propNames: string[], easing?: AnimationEasing): this;
+    pause(): void;
+    resume(): void;
+    isPaused(): boolean;
+    duration(duration: number): this;
+    private _doneCallback;
+    private _abortedCallback;
+    private _setTracksFinished;
+    private _getAdditiveTrack;
+    start(easing?: AnimationEasing): this;
+    stop(forwardToLast?: boolean): void;
+    delay(time: number): this;
+    during(cb: OnframeCallback<T>): this;
+    done(cb: DoneCallback): this;
+    aborted(cb: AbortCallback): this;
+    getClip(): Clip;
+    getTrack(propName: string): Track;
+    getTracks(): Track[];
+    stopTracks(propNames: string[], forwardToLast?: boolean): boolean;
+    saveTo(target: T, trackKeys?: readonly string[], firstOrLast?: boolean): void;
+    __changeFinalValue(finalProps: Dictionary<any>, trackKeys?: readonly string[]): void;
+}
+export declare type AnimatorTrack = Track;
+export {};

uni-demo/node_modules/zrender/lib/animation/Animator.js

@@ -0,0 +1,737 @@
+import Clip from './Clip.js';
+import * as color from '../tool/color.js';
+import { eqNaN, extend, isArrayLike, isFunction, isGradientObject, isNumber, isString, keys, logError, map } from '../core/util.js';
+import easingFuncs from './easing.js';
+import { createCubicEasingFunc } from './cubicEasing.js';
+import { isLinearGradient, isRadialGradient } from '../svg/helper.js';
+;
+var arraySlice = Array.prototype.slice;
+function interpolateNumber(p0, p1, percent) {
+    return (p1 - p0) * percent + p0;
+}
+function interpolate1DArray(out, p0, p1, percent) {
+    var len = p0.length;
+    for (var i = 0; i < len; i++) {
+        out[i] = interpolateNumber(p0[i], p1[i], percent);
+    }
+    return out;
+}
+function interpolate2DArray(out, p0, p1, percent) {
+    var len = p0.length;
+    var len2 = len && p0[0].length;
+    for (var i = 0; i < len; i++) {
+        if (!out[i]) {
+            out[i] = [];
+        }
+        for (var j = 0; j < len2; j++) {
+            out[i][j] = interpolateNumber(p0[i][j], p1[i][j], percent);
+        }
+    }
+    return out;
+}
+function add1DArray(out, p0, p1, sign) {
+    var len = p0.length;
+    for (var i = 0; i < len; i++) {
+        out[i] = p0[i] + p1[i] * sign;
+    }
+    return out;
+}
+function add2DArray(out, p0, p1, sign) {
+    var len = p0.length;
+    var len2 = len && p0[0].length;
+    for (var i = 0; i < len; i++) {
+        if (!out[i]) {
+            out[i] = [];
+        }
+        for (var j = 0; j < len2; j++) {
+            out[i][j] = p0[i][j] + p1[i][j] * sign;
+        }
+    }
+    return out;
+}
+function fillColorStops(val0, val1) {
+    var len0 = val0.length;
+    var len1 = val1.length;
+    var shorterArr = len0 > len1 ? val1 : val0;
+    var shorterLen = Math.min(len0, len1);
+    var last = shorterArr[shorterLen - 1] || { color: [0, 0, 0, 0], offset: 0 };
+    for (var i = shorterLen; i < Math.max(len0, len1); i++) {
+        shorterArr.push({
+            offset: last.offset,
+            color: last.color.slice()
+        });
+    }
+}
+function fillArray(val0, val1, arrDim) {
+    var arr0 = val0;
+    var arr1 = val1;
+    if (!arr0.push || !arr1.push) {
+        return;
+    }
+    var arr0Len = arr0.length;
+    var arr1Len = arr1.length;
+    if (arr0Len !== arr1Len) {
+        var isPreviousLarger = arr0Len > arr1Len;
+        if (isPreviousLarger) {
+            arr0.length = arr1Len;
+        }
+        else {
+            for (var i = arr0Len; i < arr1Len; i++) {
+                arr0.push(arrDim === 1 ? arr1[i] : arraySlice.call(arr1[i]));
+            }
+        }
+    }
+    var len2 = arr0[0] && arr0[0].length;
+    for (var i = 0; i < arr0.length; i++) {
+        if (arrDim === 1) {
+            if (isNaN(arr0[i])) {
+                arr0[i] = arr1[i];
+            }
+        }
+        else {
+            for (var j = 0; j < len2; j++) {
+                if (isNaN(arr0[i][j])) {
+                    arr0[i][j] = arr1[i][j];
+                }
+            }
+        }
+    }
+}
+export function cloneValue(value) {
+    if (isArrayLike(value)) {
+        var len = value.length;
+        if (isArrayLike(value[0])) {
+            var ret = [];
+            for (var i = 0; i < len; i++) {
+                ret.push(arraySlice.call(value[i]));
+            }
+            return ret;
+        }
+        return arraySlice.call(value);
+    }
+    return value;
+}
+function rgba2String(rgba) {
+    rgba[0] = Math.floor(rgba[0]) || 0;
+    rgba[1] = Math.floor(rgba[1]) || 0;
+    rgba[2] = Math.floor(rgba[2]) || 0;
+    rgba[3] = rgba[3] == null ? 1 : rgba[3];
+    return 'rgba(' + rgba.join(',') + ')';
+}
+function guessArrayDim(value) {
+    return isArrayLike(value && value[0]) ? 2 : 1;
+}
+var VALUE_TYPE_NUMBER = 0;
+var VALUE_TYPE_1D_ARRAY = 1;
+var VALUE_TYPE_2D_ARRAY = 2;
+var VALUE_TYPE_COLOR = 3;
+var VALUE_TYPE_LINEAR_GRADIENT = 4;
+var VALUE_TYPE_RADIAL_GRADIENT = 5;
+var VALUE_TYPE_UNKOWN = 6;
+function isGradientValueType(valType) {
+    return valType === VALUE_TYPE_LINEAR_GRADIENT || valType === VALUE_TYPE_RADIAL_GRADIENT;
+}
+function isArrayValueType(valType) {
+    return valType === VALUE_TYPE_1D_ARRAY || valType === VALUE_TYPE_2D_ARRAY;
+}
+var tmpRgba = [0, 0, 0, 0];
+var Track = (function () {
+    function Track(propName) {
+        this.keyframes = [];
+        this.discrete = false;
+        this._invalid = false;
+        this._needsSort = false;
+        this._lastFr = 0;
+        this._lastFrP = 0;
+        this.propName = propName;
+    }
+    Track.prototype.isFinished = function () {
+        return this._finished;
+    };
+    Track.prototype.setFinished = function () {
+        this._finished = true;
+        if (this._additiveTrack) {
+            this._additiveTrack.setFinished();
+        }
+    };
+    Track.prototype.needsAnimate = function () {
+        return this.keyframes.length >= 1;
+    };
+    Track.prototype.getAdditiveTrack = function () {
+        return this._additiveTrack;
+    };
+    Track.prototype.addKeyframe = function (time, rawValue, easing) {
+        this._needsSort = true;
+        var keyframes = this.keyframes;
+        var len = keyframes.length;
+        var discrete = false;
+        var valType = VALUE_TYPE_UNKOWN;
+        var value = rawValue;
+        if (isArrayLike(rawValue)) {
+            var arrayDim = guessArrayDim(rawValue);
+            valType = arrayDim;
+            if (arrayDim === 1 && !isNumber(rawValue[0])
+                || arrayDim === 2 && !isNumber(rawValue[0][0])) {
+                discrete = true;
+            }
+        }
+        else {
+            if (isNumber(rawValue) && !eqNaN(rawValue)) {
+                valType = VALUE_TYPE_NUMBER;
+            }
+            else if (isString(rawValue)) {
+                if (!isNaN(+rawValue)) {
+                    valType = VALUE_TYPE_NUMBER;
+                }
+                else {
+                    var colorArray = color.parse(rawValue);
+                    if (colorArray) {
+                        value = colorArray;
+                        valType = VALUE_TYPE_COLOR;
+                    }
+                }
+            }
+            else if (isGradientObject(rawValue)) {
+                var parsedGradient = extend({}, value);
+                parsedGradient.colorStops = map(rawValue.colorStops, function (colorStop) { return ({
+                    offset: colorStop.offset,
+                    color: color.parse(colorStop.color)
+                }); });
+                if (isLinearGradient(rawValue)) {
+                    valType = VALUE_TYPE_LINEAR_GRADIENT;
+                }
+                else if (isRadialGradient(rawValue)) {
+                    valType = VALUE_TYPE_RADIAL_GRADIENT;
+                }
+                value = parsedGradient;
+            }
+        }
+        if (len === 0) {
+            this.valType = valType;
+        }
+        else if (valType !== this.valType || valType === VALUE_TYPE_UNKOWN) {
+            discrete = true;
+        }
+        this.discrete = this.discrete || discrete;
+        var kf = {
+            time: time,
+            value: value,
+            rawValue: rawValue,
+            percent: 0
+        };
+        if (easing) {
+            kf.easing = easing;
+            kf.easingFunc = isFunction(easing)
+                ? easing
+                : easingFuncs[easing] || createCubicEasingFunc(easing);
+        }
+        keyframes.push(kf);
+        return kf;
+    };
+    Track.prototype.prepare = function (maxTime, additiveTrack) {
+        var kfs = this.keyframes;
+        if (this._needsSort) {
+            kfs.sort(function (a, b) {
+                return a.time - b.time;
+            });
+        }
+        var valType = this.valType;
+        var kfsLen = kfs.length;
+        var lastKf = kfs[kfsLen - 1];
+        var isDiscrete = this.discrete;
+        var isArr = isArrayValueType(valType);
+        var isGradient = isGradientValueType(valType);
+        for (var i = 0; i < kfsLen; i++) {
+            var kf = kfs[i];
+            var value = kf.value;
+            var lastValue = lastKf.value;
+            kf.percent = kf.time / maxTime;
+            if (!isDiscrete) {
+                if (isArr && i !== kfsLen - 1) {
+                    fillArray(value, lastValue, valType);
+                }
+                else if (isGradient) {
+                    fillColorStops(value.colorStops, lastValue.colorStops);
+                }
+            }
+        }
+        if (!isDiscrete
+            && valType !== VALUE_TYPE_RADIAL_GRADIENT
+            && additiveTrack
+            && this.needsAnimate()
+            && additiveTrack.needsAnimate()
+            && valType === additiveTrack.valType
+            && !additiveTrack._finished) {
+            this._additiveTrack = additiveTrack;
+            var startValue = kfs[0].value;
+            for (var i = 0; i < kfsLen; i++) {
+                if (valType === VALUE_TYPE_NUMBER) {
+                    kfs[i].additiveValue = kfs[i].value - startValue;
+                }
+                else if (valType === VALUE_TYPE_COLOR) {
+                    kfs[i].additiveValue =
+                        add1DArray([], kfs[i].value, startValue, -1);
+                }
+                else if (isArrayValueType(valType)) {
+                    kfs[i].additiveValue = valType === VALUE_TYPE_1D_ARRAY
+                        ? add1DArray([], kfs[i].value, startValue, -1)
+                        : add2DArray([], kfs[i].value, startValue, -1);
+                }
+            }
+        }
+    };
+    Track.prototype.step = function (target, percent) {
+        if (this._finished) {
+            return;
+        }
+        if (this._additiveTrack && this._additiveTrack._finished) {
+            this._additiveTrack = null;
+        }
+        var isAdditive = this._additiveTrack != null;
+        var valueKey = isAdditive ? 'additiveValue' : 'value';
+        var valType = this.valType;
+        var keyframes = this.keyframes;
+        var kfsNum = keyframes.length;
+        var propName = this.propName;
+        var isValueColor = valType === VALUE_TYPE_COLOR;
+        var frameIdx;
+        var lastFrame = this._lastFr;
+        var mathMin = Math.min;
+        var frame;
+        var nextFrame;
+        if (kfsNum === 1) {
+            frame = nextFrame = keyframes[0];
+        }
+        else {
+            if (percent < 0) {
+                frameIdx = 0;
+            }
+            else if (percent < this._lastFrP) {
+                var start = mathMin(lastFrame + 1, kfsNum - 1);
+                for (frameIdx = start; frameIdx >= 0; frameIdx--) {
+                    if (keyframes[frameIdx].percent <= percent) {
+                        break;
+                    }
+                }
+                frameIdx = mathMin(frameIdx, kfsNum - 2);
+            }
+            else {
+                for (frameIdx = lastFrame; frameIdx < kfsNum; frameIdx++) {
+                    if (keyframes[frameIdx].percent > percent) {
+                        break;
+                    }
+                }
+                frameIdx = mathMin(frameIdx - 1, kfsNum - 2);
+            }
+            nextFrame = keyframes[frameIdx + 1];
+            frame = keyframes[frameIdx];
+        }
+        if (!(frame && nextFrame)) {
+            return;
+        }
+        this._lastFr = frameIdx;
+        this._lastFrP = percent;
+        var interval = (nextFrame.percent - frame.percent);
+        var w = interval === 0 ? 1 : mathMin((percent - frame.percent) / interval, 1);
+        if (nextFrame.easingFunc) {
+            w = nextFrame.easingFunc(w);
+        }
+        var targetArr = isAdditive ? this._additiveValue
+            : (isValueColor ? tmpRgba : target[propName]);
+        if ((isArrayValueType(valType) || isValueColor) && !targetArr) {
+            targetArr = this._additiveValue = [];
+        }
+        if (this.discrete) {
+            target[propName] = w < 1 ? frame.rawValue : nextFrame.rawValue;
+        }
+        else if (isArrayValueType(valType)) {
+            valType === VALUE_TYPE_1D_ARRAY
+                ? interpolate1DArray(targetArr, frame[valueKey], nextFrame[valueKey], w)
+                : interpolate2DArray(targetArr, frame[valueKey], nextFrame[valueKey], w);
+        }
+        else if (isGradientValueType(valType)) {
+            var val = frame[valueKey];
+            var nextVal_1 = nextFrame[valueKey];
+            var isLinearGradient_1 = valType === VALUE_TYPE_LINEAR_GRADIENT;
+            target[propName] = {
+                type: isLinearGradient_1 ? 'linear' : 'radial',
+                x: interpolateNumber(val.x, nextVal_1.x, w),
+                y: interpolateNumber(val.y, nextVal_1.y, w),
+                colorStops: map(val.colorStops, function (colorStop, idx) {
+                    var nextColorStop = nextVal_1.colorStops[idx];
+                    return {
+                        offset: interpolateNumber(colorStop.offset, nextColorStop.offset, w),
+                        color: rgba2String(interpolate1DArray([], colorStop.color, nextColorStop.color, w))
+                    };
+                }),
+                global: nextVal_1.global
+            };
+            if (isLinearGradient_1) {
+                target[propName].x2 = interpolateNumber(val.x2, nextVal_1.x2, w);
+                target[propName].y2 = interpolateNumber(val.y2, nextVal_1.y2, w);
+            }
+            else {
+                target[propName].r = interpolateNumber(val.r, nextVal_1.r, w);
+            }
+        }
+        else if (isValueColor) {
+            interpolate1DArray(targetArr, frame[valueKey], nextFrame[valueKey], w);
+            if (!isAdditive) {
+                target[propName] = rgba2String(targetArr);
+            }
+        }
+        else {
+            var value = interpolateNumber(frame[valueKey], nextFrame[valueKey], w);
+            if (isAdditive) {
+                this._additiveValue = value;
+            }
+            else {
+                target[propName] = value;
+            }
+        }
+        if (isAdditive) {
+            this._addToTarget(target);
+        }
+    };
+    Track.prototype._addToTarget = function (target) {
+        var valType = this.valType;
+        var propName = this.propName;
+        var additiveValue = this._additiveValue;
+        if (valType === VALUE_TYPE_NUMBER) {
+            target[propName] = target[propName] + additiveValue;
+        }
+        else if (valType === VALUE_TYPE_COLOR) {
+            color.parse(target[propName], tmpRgba);
+            add1DArray(tmpRgba, tmpRgba, additiveValue, 1);
+            target[propName] = rgba2String(tmpRgba);
+        }
+        else if (valType === VALUE_TYPE_1D_ARRAY) {
+            add1DArray(target[propName], target[propName], additiveValue, 1);
+        }
+        else if (valType === VALUE_TYPE_2D_ARRAY) {
+            add2DArray(target[propName], target[propName], additiveValue, 1);
+        }
+    };
+    return Track;
+}());
+var Animator = (function () {
+    function Animator(target, loop, allowDiscreteAnimation, additiveTo) {
+        this._tracks = {};
+        this._trackKeys = [];
+        this._maxTime = 0;
+        this._started = 0;
+        this._clip = null;
+        this._target = target;
+        this._loop = loop;
+        if (loop && additiveTo) {
+            logError('Can\' use additive animation on looped animation.');
+            return;
+        }
+        this._additiveAnimators = additiveTo;
+        this._allowDiscrete = allowDiscreteAnimation;
+    }
+    Animator.prototype.getMaxTime = function () {
+        return this._maxTime;
+    };
+    Animator.prototype.getDelay = function () {
+        return this._delay;
+    };
+    Animator.prototype.getLoop = function () {
+        return this._loop;
+    };
+    Animator.prototype.getTarget = function () {
+        return this._target;
+    };
+    Animator.prototype.changeTarget = function (target) {
+        this._target = target;
+    };
+    Animator.prototype.when = function (time, props, easing) {
+        return this.whenWithKeys(time, props, keys(props), easing);
+    };
+    Animator.prototype.whenWithKeys = function (time, props, propNames, easing) {
+        var tracks = this._tracks;
+        for (var i = 0; i < propNames.length; i++) {
+            var propName = propNames[i];
+            var track = tracks[propName];
+            if (!track) {
+                track = tracks[propName] = new Track(propName);
+                var initialValue = void 0;
+                var additiveTrack = this._getAdditiveTrack(propName);
+                if (additiveTrack) {
+                    var addtiveTrackKfs = additiveTrack.keyframes;
+                    var lastFinalKf = addtiveTrackKfs[addtiveTrackKfs.length - 1];
+                    initialValue = lastFinalKf && lastFinalKf.value;
+                    if (additiveTrack.valType === VALUE_TYPE_COLOR && initialValue) {
+                        initialValue = rgba2String(initialValue);
+                    }
+                }
+                else {
+                    initialValue = this._target[propName];
+                }
+                if (initialValue == null) {
+                    continue;
+                }
+                if (time > 0) {
+                    track.addKeyframe(0, cloneValue(initialValue), easing);
+                }
+                this._trackKeys.push(propName);
+            }
+            track.addKeyframe(time, cloneValue(props[propName]), easing);
+        }
+        this._maxTime = Math.max(this._maxTime, time);
+        return this;
+    };
+    Animator.prototype.pause = function () {
+        this._clip.pause();
+        this._paused = true;
+    };
+    Animator.prototype.resume = function () {
+        this._clip.resume();
+        this._paused = false;
+    };
+    Animator.prototype.isPaused = function () {
+        return !!this._paused;
+    };
+    Animator.prototype.duration = function (duration) {
+        this._maxTime = duration;
+        this._force = true;
+        return this;
+    };
+    Animator.prototype._doneCallback = function () {
+        this._setTracksFinished();
+        this._clip = null;
+        var doneList = this._doneCbs;
+        if (doneList) {
+            var len = doneList.length;
+            for (var i = 0; i < len; i++) {
+                doneList[i].call(this);
+            }
+        }
+    };
+    Animator.prototype._abortedCallback = function () {
+        this._setTracksFinished();
+        var animation = this.animation;
+        var abortedList = this._abortedCbs;
+        if (animation) {
+            animation.removeClip(this._clip);
+        }
+        this._clip = null;
+        if (abortedList) {
+            for (var i = 0; i < abortedList.length; i++) {
+                abortedList[i].call(this);
+            }
+        }
+    };
+    Animator.prototype._setTracksFinished = function () {
+        var tracks = this._tracks;
+        var tracksKeys = this._trackKeys;
+        for (var i = 0; i < tracksKeys.length; i++) {
+            tracks[tracksKeys[i]].setFinished();
+        }
+    };
+    Animator.prototype._getAdditiveTrack = function (trackName) {
+        var additiveTrack;
+        var additiveAnimators = this._additiveAnimators;
+        if (additiveAnimators) {
+            for (var i = 0; i < additiveAnimators.length; i++) {
+                var track = additiveAnimators[i].getTrack(trackName);
+                if (track) {
+                    additiveTrack = track;
+                }
+            }
+        }
+        return additiveTrack;
+    };
+    Animator.prototype.start = function (easing) {
+        if (this._started > 0) {
+            return;
+        }
+        this._started = 1;
+        var self = this;
+        var tracks = [];
+        var maxTime = this._maxTime || 0;
+        for (var i = 0; i < this._trackKeys.length; i++) {
+            var propName = this._trackKeys[i];
+            var track = this._tracks[propName];
+            var additiveTrack = this._getAdditiveTrack(propName);
+            var kfs = track.keyframes;
+            var kfsNum = kfs.length;
+            track.prepare(maxTime, additiveTrack);
+            if (track.needsAnimate()) {
+                if (!this._allowDiscrete && track.discrete) {
+                    var lastKf = kfs[kfsNum - 1];
+                    if (lastKf) {
+                        self._target[track.propName] = lastKf.rawValue;
+                    }
+                    track.setFinished();
+                }
+                else {
+                    tracks.push(track);
+                }
+            }
+        }
+        if (tracks.length || this._force) {
+            var clip = new Clip({
+                life: maxTime,
+                loop: this._loop,
+                delay: this._delay || 0,
+                onframe: function (percent) {
+                    self._started = 2;
+                    var additiveAnimators = self._additiveAnimators;
+                    if (additiveAnimators) {
+                        var stillHasAdditiveAnimator = false;
+                        for (var i = 0; i < additiveAnimators.length; i++) {
+                            if (additiveAnimators[i]._clip) {
+                                stillHasAdditiveAnimator = true;
+                                break;
+                            }
+                        }
+                        if (!stillHasAdditiveAnimator) {
+                            self._additiveAnimators = null;
+                        }
+                    }
+                    for (var i = 0; i < tracks.length; i++) {
+                        tracks[i].step(self._target, percent);
+                    }
+                    var onframeList = self._onframeCbs;
+                    if (onframeList) {
+                        for (var i = 0; i < onframeList.length; i++) {
+                            onframeList[i](self._target, percent);
+                        }
+                    }
+                },
+                ondestroy: function () {
+                    self._doneCallback();
+                }
+            });
+            this._clip = clip;
+            if (this.animation) {
+                this.animation.addClip(clip);
+            }
+            if (easing) {
+                clip.setEasing(easing);
+            }
+        }
+        else {
+            this._doneCallback();
+        }
+        return this;
+    };
+    Animator.prototype.stop = function (forwardToLast) {
+        if (!this._clip) {
+            return;
+        }
+        var clip = this._clip;
+        if (forwardToLast) {
+            clip.onframe(1);
+        }
+        this._abortedCallback();
+    };
+    Animator.prototype.delay = function (time) {
+        this._delay = time;
+        return this;
+    };
+    Animator.prototype.during = function (cb) {
+        if (cb) {
+            if (!this._onframeCbs) {
+                this._onframeCbs = [];
+            }
+            this._onframeCbs.push(cb);
+        }
+        return this;
+    };
+    Animator.prototype.done = function (cb) {
+        if (cb) {
+            if (!this._doneCbs) {
+                this._doneCbs = [];
+            }
+            this._doneCbs.push(cb);
+        }
+        return this;
+    };
+    Animator.prototype.aborted = function (cb) {
+        if (cb) {
+            if (!this._abortedCbs) {
+                this._abortedCbs = [];
+            }
+            this._abortedCbs.push(cb);
+        }
+        return this;
+    };
+    Animator.prototype.getClip = function () {
+        return this._clip;
+    };
+    Animator.prototype.getTrack = function (propName) {
+        return this._tracks[propName];
+    };
+    Animator.prototype.getTracks = function () {
+        var _this = this;
+        return map(this._trackKeys, function (key) { return _this._tracks[key]; });
+    };
+    Animator.prototype.stopTracks = function (propNames, forwardToLast) {
+        if (!propNames.length || !this._clip) {
+            return true;
+        }
+        var tracks = this._tracks;
+        var tracksKeys = this._trackKeys;
+        for (var i = 0; i < propNames.length; i++) {
+            var track = tracks[propNames[i]];
+            if (track && !track.isFinished()) {
+                if (forwardToLast) {
+                    track.step(this._target, 1);
+                }
+                else if (this._started === 1) {
+                    track.step(this._target, 0);
+                }
+                track.setFinished();
+            }
+        }
+        var allAborted = true;
+        for (var i = 0; i < tracksKeys.length; i++) {
+            if (!tracks[tracksKeys[i]].isFinished()) {
+                allAborted = false;
+                break;
+            }
+        }
+        if (allAborted) {
+            this._abortedCallback();
+        }
+        return allAborted;
+    };
+    Animator.prototype.saveTo = function (target, trackKeys, firstOrLast) {
+        if (!target) {
+            return;
+        }
+        trackKeys = trackKeys || this._trackKeys;
+        for (var i = 0; i < trackKeys.length; i++) {
+            var propName = trackKeys[i];
+            var track = this._tracks[propName];
+            if (!track || track.isFinished()) {
+                continue;
+            }
+            var kfs = track.keyframes;
+            var kf = kfs[firstOrLast ? 0 : kfs.length - 1];
+            if (kf) {
+                target[propName] = cloneValue(kf.rawValue);
+            }
+        }
+    };
+    Animator.prototype.__changeFinalValue = function (finalProps, trackKeys) {
+        trackKeys = trackKeys || keys(finalProps);
+        for (var i = 0; i < trackKeys.length; i++) {
+            var propName = trackKeys[i];
+            var track = this._tracks[propName];
+            if (!track) {
+                continue;
+            }
+            var kfs = track.keyframes;
+            if (kfs.length > 1) {
+                var lastKf = kfs.pop();
+                track.addKeyframe(lastKf.time, finalProps[propName]);
+                track.prepare(this._maxTime, track.getAdditiveTrack());
+            }
+        }
+    };
+    return Animator;
+}());
+export default Animator;

uni-demo/node_modules/zrender/lib/animation/Clip.d.ts

@@ -0,0 +1,38 @@
+import { AnimationEasing } from './easing';
+import type Animation from './Animation';
+declare type OnframeCallback = (percent: number) => void;
+declare type ondestroyCallback = () => void;
+declare type onrestartCallback = () => void;
+export declare type DeferredEventTypes = 'destroy' | 'restart';
+export interface ClipProps {
+    life?: number;
+    delay?: number;
+    loop?: boolean;
+    easing?: AnimationEasing;
+    onframe?: OnframeCallback;
+    ondestroy?: ondestroyCallback;
+    onrestart?: onrestartCallback;
+}
+export default class Clip {
+    private _life;
+    private _delay;
+    private _inited;
+    private _startTime;
+    private _pausedTime;
+    private _paused;
+    animation: Animation;
+    loop: boolean;
+    easing: AnimationEasing;
+    easingFunc: (p: number) => number;
+    next: Clip;
+    prev: Clip;
+    onframe: OnframeCallback;
+    ondestroy: ondestroyCallback;
+    onrestart: onrestartCallback;
+    constructor(opts: ClipProps);
+    step(globalTime: number, deltaTime: number): boolean;
+    pause(): void;
+    resume(): void;
+    setEasing(easing: AnimationEasing): void;
+}
+export {};

uni-demo/node_modules/zrender/lib/animation/Clip.js

@@ -0,0 +1,64 @@
+import easingFuncs from './easing.js';
+import { isFunction, noop } from '../core/util.js';
+import { createCubicEasingFunc } from './cubicEasing.js';
+var Clip = (function () {
+    function Clip(opts) {
+        this._inited = false;
+        this._startTime = 0;
+        this._pausedTime = 0;
+        this._paused = false;
+        this._life = opts.life || 1000;
+        this._delay = opts.delay || 0;
+        this.loop = opts.loop || false;
+        this.onframe = opts.onframe || noop;
+        this.ondestroy = opts.ondestroy || noop;
+        this.onrestart = opts.onrestart || noop;
+        opts.easing && this.setEasing(opts.easing);
+    }
+    Clip.prototype.step = function (globalTime, deltaTime) {
+        if (!this._inited) {
+            this._startTime = globalTime + this._delay;
+            this._inited = true;
+        }
+        if (this._paused) {
+            this._pausedTime += deltaTime;
+            return;
+        }
+        var life = this._life;
+        var elapsedTime = globalTime - this._startTime - this._pausedTime;
+        var percent = elapsedTime / life;
+        if (percent < 0) {
+            percent = 0;
+        }
+        percent = Math.min(percent, 1);
+        var easingFunc = this.easingFunc;
+        var schedule = easingFunc ? easingFunc(percent) : percent;
+        this.onframe(schedule);
+        if (percent === 1) {
+            if (this.loop) {
+                var remainder = elapsedTime % life;
+                this._startTime = globalTime - remainder;
+                this._pausedTime = 0;
+                this.onrestart();
+            }
+            else {
+                return true;
+            }
+        }
+        return false;
+    };
+    Clip.prototype.pause = function () {
+        this._paused = true;
+    };
+    Clip.prototype.resume = function () {
+        this._paused = false;
+    };
+    Clip.prototype.setEasing = function (easing) {
+        this.easing = easing;
+        this.easingFunc = isFunction(easing)
+            ? easing
+            : easingFuncs[easing] || createCubicEasingFunc(easing);
+    };
+    return Clip;
+}());
+export default Clip;

uni-demo/node_modules/zrender/lib/animation/cubicEasing.d.ts

@@ -0,0 +1 @@
+export declare function createCubicEasingFunc(cubicEasingStr: string): (p: number) => number;

uni-demo/node_modules/zrender/lib/animation/cubicEasing.js

@@ -0,0 +1,23 @@
+import { cubicAt, cubicRootAt } from '../core/curve.js';
+import { trim } from '../core/util.js';
+var regexp = /cubic-bezier\(([0-9,\.e ]+)\)/;
+export function createCubicEasingFunc(cubicEasingStr) {
+    var cubic = cubicEasingStr && regexp.exec(cubicEasingStr);
+    if (cubic) {
+        var points = cubic[1].split(',');
+        var a_1 = +trim(points[0]);
+        var b_1 = +trim(points[1]);
+        var c_1 = +trim(points[2]);
+        var d_1 = +trim(points[3]);
+        if (isNaN(a_1 + b_1 + c_1 + d_1)) {
+            return;
+        }
+        var roots_1 = [];
+        return function (p) {
+            return p <= 0
+                ? 0 : p >= 1
+                ? 1
+                : cubicRootAt(0, a_1, c_1, 1, p, roots_1) && cubicAt(0, b_1, d_1, 1, roots_1[0]);
+        };
+    }
+}

uni-demo/node_modules/zrender/lib/animation/easing.d.ts

@@ -0,0 +1,36 @@
+declare type easingFunc = (percent: number) => number;
+export declare type AnimationEasing = keyof typeof easingFuncs | easingFunc;
+declare const easingFuncs: {
+    linear(k: number): number;
+    quadraticIn(k: number): number;
+    quadraticOut(k: number): number;
+    quadraticInOut(k: number): number;
+    cubicIn(k: number): number;
+    cubicOut(k: number): number;
+    cubicInOut(k: number): number;
+    quarticIn(k: number): number;
+    quarticOut(k: number): number;
+    quarticInOut(k: number): number;
+    quinticIn(k: number): number;
+    quinticOut(k: number): number;
+    quinticInOut(k: number): number;
+    sinusoidalIn(k: number): number;
+    sinusoidalOut(k: number): number;
+    sinusoidalInOut(k: number): number;
+    exponentialIn(k: number): number;
+    exponentialOut(k: number): number;
+    exponentialInOut(k: number): number;
+    circularIn(k: number): number;
+    circularOut(k: number): number;
+    circularInOut(k: number): number;
+    elasticIn(k: number): number;
+    elasticOut(k: number): number;
+    elasticInOut(k: number): number;
+    backIn(k: number): number;
+    backOut(k: number): number;
+    backInOut(k: number): number;
+    bounceIn(k: number): number;
+    bounceOut(k: number): number;
+    bounceInOut(k: number): number;
+};
+export default easingFuncs;

uni-demo/node_modules/zrender/lib/animation/easing.js

@@ -0,0 +1,195 @@
+var easingFuncs = {
+    linear: function (k) {
+        return k;
+    },
+    quadraticIn: function (k) {
+        return k * k;
+    },
+    quadraticOut: function (k) {
+        return k * (2 - k);
+    },
+    quadraticInOut: function (k) {
+        if ((k *= 2) < 1) {
+            return 0.5 * k * k;
+        }
+        return -0.5 * (--k * (k - 2) - 1);
+    },
+    cubicIn: function (k) {
+        return k * k * k;
+    },
+    cubicOut: function (k) {
+        return --k * k * k + 1;
+    },
+    cubicInOut: function (k) {
+        if ((k *= 2) < 1) {
+            return 0.5 * k * k * k;
+        }
+        return 0.5 * ((k -= 2) * k * k + 2);
+    },
+    quarticIn: function (k) {
+        return k * k * k * k;
+    },
+    quarticOut: function (k) {
+        return 1 - (--k * k * k * k);
+    },
+    quarticInOut: function (k) {
+        if ((k *= 2) < 1) {
+            return 0.5 * k * k * k * k;
+        }
+        return -0.5 * ((k -= 2) * k * k * k - 2);
+    },
+    quinticIn: function (k) {
+        return k * k * k * k * k;
+    },
+    quinticOut: function (k) {
+        return --k * k * k * k * k + 1;
+    },
+    quinticInOut: function (k) {
+        if ((k *= 2) < 1) {
+            return 0.5 * k * k * k * k * k;
+        }
+        return 0.5 * ((k -= 2) * k * k * k * k + 2);
+    },
+    sinusoidalIn: function (k) {
+        return 1 - Math.cos(k * Math.PI / 2);
+    },
+    sinusoidalOut: function (k) {
+        return Math.sin(k * Math.PI / 2);
+    },
+    sinusoidalInOut: function (k) {
+        return 0.5 * (1 - Math.cos(Math.PI * k));
+    },
+    exponentialIn: function (k) {
+        return k === 0 ? 0 : Math.pow(1024, k - 1);
+    },
+    exponentialOut: function (k) {
+        return k === 1 ? 1 : 1 - Math.pow(2, -10 * k);
+    },
+    exponentialInOut: function (k) {
+        if (k === 0) {
+            return 0;
+        }
+        if (k === 1) {
+            return 1;
+        }
+        if ((k *= 2) < 1) {
+            return 0.5 * Math.pow(1024, k - 1);
+        }
+        return 0.5 * (-Math.pow(2, -10 * (k - 1)) + 2);
+    },
+    circularIn: function (k) {
+        return 1 - Math.sqrt(1 - k * k);
+    },
+    circularOut: function (k) {
+        return Math.sqrt(1 - (--k * k));
+    },
+    circularInOut: function (k) {
+        if ((k *= 2) < 1) {
+            return -0.5 * (Math.sqrt(1 - k * k) - 1);
+        }
+        return 0.5 * (Math.sqrt(1 - (k -= 2) * k) + 1);
+    },
+    elasticIn: function (k) {
+        var s;
+        var a = 0.1;
+        var p = 0.4;
+        if (k === 0) {
+            return 0;
+        }
+        if (k === 1) {
+            return 1;
+        }
+        if (!a || a < 1) {
+            a = 1;
+            s = p / 4;
+        }
+        else {
+            s = p * Math.asin(1 / a) / (2 * Math.PI);
+        }
+        return -(a * Math.pow(2, 10 * (k -= 1))
+            * Math.sin((k - s) * (2 * Math.PI) / p));
+    },
+    elasticOut: function (k) {
+        var s;
+        var a = 0.1;
+        var p = 0.4;
+        if (k === 0) {
+            return 0;
+        }
+        if (k === 1) {
+            return 1;
+        }
+        if (!a || a < 1) {
+            a = 1;
+            s = p / 4;
+        }
+        else {
+            s = p * Math.asin(1 / a) / (2 * Math.PI);
+        }
+        return (a * Math.pow(2, -10 * k)
+            * Math.sin((k - s) * (2 * Math.PI) / p) + 1);
+    },
+    elasticInOut: function (k) {
+        var s;
+        var a = 0.1;
+        var p = 0.4;
+        if (k === 0) {
+            return 0;
+        }
+        if (k === 1) {
+            return 1;
+        }
+        if (!a || a < 1) {
+            a = 1;
+            s = p / 4;
+        }
+        else {
+            s = p * Math.asin(1 / a) / (2 * Math.PI);
+        }
+        if ((k *= 2) < 1) {
+            return -0.5 * (a * Math.pow(2, 10 * (k -= 1))
+                * Math.sin((k - s) * (2 * Math.PI) / p));
+        }
+        return a * Math.pow(2, -10 * (k -= 1))
+            * Math.sin((k - s) * (2 * Math.PI) / p) * 0.5 + 1;
+    },
+    backIn: function (k) {
+        var s = 1.70158;
+        return k * k * ((s + 1) * k - s);
+    },
+    backOut: function (k) {
+        var s = 1.70158;
+        return --k * k * ((s + 1) * k + s) + 1;
+    },
+    backInOut: function (k) {
+        var s = 1.70158 * 1.525;
+        if ((k *= 2) < 1) {
+            return 0.5 * (k * k * ((s + 1) * k - s));
+        }
+        return 0.5 * ((k -= 2) * k * ((s + 1) * k + s) + 2);
+    },
+    bounceIn: function (k) {
+        return 1 - easingFuncs.bounceOut(1 - k);
+    },
+    bounceOut: function (k) {
+        if (k < (1 / 2.75)) {
+            return 7.5625 * k * k;
+        }
+        else if (k < (2 / 2.75)) {
+            return 7.5625 * (k -= (1.5 / 2.75)) * k + 0.75;
+        }
+        else if (k < (2.5 / 2.75)) {
+            return 7.5625 * (k -= (2.25 / 2.75)) * k + 0.9375;
+        }
+        else {
+            return 7.5625 * (k -= (2.625 / 2.75)) * k + 0.984375;
+        }
+    },
+    bounceInOut: function (k) {
+        if (k < 0.5) {
+            return easingFuncs.bounceIn(k * 2) * 0.5;
+        }
+        return easingFuncs.bounceOut(k * 2 - 1) * 0.5 + 0.5;
+    }
+};
+export default easingFuncs;

uni-demo/node_modules/zrender/lib/animation/requestAnimationFrame.d.ts

@@ -0,0 +1,3 @@
+declare type RequestAnimationFrameType = typeof window.requestAnimationFrame;
+declare let requestAnimationFrame: RequestAnimationFrameType;
+export default requestAnimationFrame;

uni-demo/node_modules/zrender/lib/animation/requestAnimationFrame.js

@@ -0,0 +1,10 @@
+import env from '../core/env.js';
+var requestAnimationFrame;
+requestAnimationFrame = (env.hasGlobalWindow
+    && ((window.requestAnimationFrame && window.requestAnimationFrame.bind(window))
+        || (window.msRequestAnimationFrame && window.msRequestAnimationFrame.bind(window))
+        || window.mozRequestAnimationFrame
+        || window.webkitRequestAnimationFrame)) || function (func) {
+    return setTimeout(func, 16);
+};
+export default requestAnimationFrame;

uni-demo/node_modules/zrender/lib/canvas/Layer.d.ts

@@ -0,0 +1,68 @@
+import { ImagePatternObject } from '../graphic/Pattern';
+import CanvasPainter from './Painter';
+import { GradientObject } from '../graphic/Gradient';
+import Eventful from '../core/Eventful';
+import { ElementEventCallback } from '../Element';
+import Displayable from '../graphic/Displayable';
+import BoundingRect from '../core/BoundingRect';
+export interface LayerConfig {
+    clearColor?: string | GradientObject | ImagePatternObject;
+    motionBlur?: boolean;
+    lastFrameAlpha?: number;
+}
+export default class Layer extends Eventful {
+    id: string;
+    dom: HTMLCanvasElement;
+    domBack: HTMLCanvasElement;
+    ctx: CanvasRenderingContext2D;
+    ctxBack: CanvasRenderingContext2D;
+    painter: CanvasPainter;
+    clearColor: string | GradientObject | ImagePatternObject;
+    motionBlur: boolean;
+    lastFrameAlpha: number;
+    dpr: number;
+    virtual: boolean;
+    config: {};
+    incremental: boolean;
+    zlevel: number;
+    maxRepaintRectCount: number;
+    private _paintRects;
+    __painter: CanvasPainter;
+    __dirty: boolean;
+    __firstTimePaint: boolean;
+    __used: boolean;
+    __drawIndex: number;
+    __startIndex: number;
+    __endIndex: number;
+    __prevStartIndex: number;
+    __prevEndIndex: number;
+    __builtin__: boolean;
+    constructor(id: string | HTMLCanvasElement, painter: CanvasPainter, dpr?: number);
+    getElementCount(): number;
+    afterBrush(): void;
+    initContext(): void;
+    setUnpainted(): void;
+    createBackBuffer(): void;
+    createRepaintRects(displayList: Displayable[], prevList: Displayable[], viewWidth: number, viewHeight: number): BoundingRect[];
+    debugGetPaintRects(): BoundingRect[];
+    resize(width: number, height: number): void;
+    clear(clearAll?: boolean, clearColor?: string | GradientObject | ImagePatternObject, repaintRects?: BoundingRect[]): void;
+    refresh: (clearColor?: string | GradientObject | ImagePatternObject) => void;
+    renderToCanvas: (ctx: CanvasRenderingContext2D) => void;
+    onclick: ElementEventCallback<unknown, this>;
+    ondblclick: ElementEventCallback<unknown, this>;
+    onmouseover: ElementEventCallback<unknown, this>;
+    onmouseout: ElementEventCallback<unknown, this>;
+    onmousemove: ElementEventCallback<unknown, this>;
+    onmousewheel: ElementEventCallback<unknown, this>;
+    onmousedown: ElementEventCallback<unknown, this>;
+    onmouseup: ElementEventCallback<unknown, this>;
+    oncontextmenu: ElementEventCallback<unknown, this>;
+    ondrag: ElementEventCallback<unknown, this>;
+    ondragstart: ElementEventCallback<unknown, this>;
+    ondragend: ElementEventCallback<unknown, this>;
+    ondragenter: ElementEventCallback<unknown, this>;
+    ondragleave: ElementEventCallback<unknown, this>;
+    ondragover: ElementEventCallback<unknown, this>;
+    ondrop: ElementEventCallback<unknown, this>;
+}

uni-demo/node_modules/zrender/lib/canvas/Layer.js

@@ -0,0 +1,290 @@
+import { __extends } from "tslib";
+import * as util from '../core/util.js';
+import { devicePixelRatio } from '../config.js';
+import Eventful from '../core/Eventful.js';
+import { getCanvasGradient } from './helper.js';
+import { createCanvasPattern } from './graphic.js';
+import BoundingRect from '../core/BoundingRect.js';
+import { REDRAW_BIT } from '../graphic/constants.js';
+import { platformApi } from '../core/platform.js';
+function createDom(id, painter, dpr) {
+    var newDom = platformApi.createCanvas();
+    var width = painter.getWidth();
+    var height = painter.getHeight();
+    var newDomStyle = newDom.style;
+    if (newDomStyle) {
+        newDomStyle.position = 'absolute';
+        newDomStyle.left = '0';
+        newDomStyle.top = '0';
+        newDomStyle.width = width + 'px';
+        newDomStyle.height = height + 'px';
+        newDom.setAttribute('data-zr-dom-id', id);
+    }
+    newDom.width = width * dpr;
+    newDom.height = height * dpr;
+    return newDom;
+}
+;
+var Layer = (function (_super) {
+    __extends(Layer, _super);
+    function Layer(id, painter, dpr) {
+        var _this = _super.call(this) || this;
+        _this.motionBlur = false;
+        _this.lastFrameAlpha = 0.7;
+        _this.dpr = 1;
+        _this.virtual = false;
+        _this.config = {};
+        _this.incremental = false;
+        _this.zlevel = 0;
+        _this.maxRepaintRectCount = 5;
+        _this.__dirty = true;
+        _this.__firstTimePaint = true;
+        _this.__used = false;
+        _this.__drawIndex = 0;
+        _this.__startIndex = 0;
+        _this.__endIndex = 0;
+        _this.__prevStartIndex = null;
+        _this.__prevEndIndex = null;
+        var dom;
+        dpr = dpr || devicePixelRatio;
+        if (typeof id === 'string') {
+            dom = createDom(id, painter, dpr);
+        }
+        else if (util.isObject(id)) {
+            dom = id;
+            id = dom.id;
+        }
+        _this.id = id;
+        _this.dom = dom;
+        var domStyle = dom.style;
+        if (domStyle) {
+            util.disableUserSelect(dom);
+            dom.onselectstart = function () { return false; };
+            domStyle.padding = '0';
+            domStyle.margin = '0';
+            domStyle.borderWidth = '0';
+        }
+        _this.painter = painter;
+        _this.dpr = dpr;
+        return _this;
+    }
+    Layer.prototype.getElementCount = function () {
+        return this.__endIndex - this.__startIndex;
+    };
+    Layer.prototype.afterBrush = function () {
+        this.__prevStartIndex = this.__startIndex;
+        this.__prevEndIndex = this.__endIndex;
+    };
+    Layer.prototype.initContext = function () {
+        this.ctx = this.dom.getContext('2d');
+        this.ctx.dpr = this.dpr;
+    };
+    Layer.prototype.setUnpainted = function () {
+        this.__firstTimePaint = true;
+    };
+    Layer.prototype.createBackBuffer = function () {
+        var dpr = this.dpr;
+        this.domBack = createDom('back-' + this.id, this.painter, dpr);
+        this.ctxBack = this.domBack.getContext('2d');
+        if (dpr !== 1) {
+            this.ctxBack.scale(dpr, dpr);
+        }
+    };
+    Layer.prototype.createRepaintRects = function (displayList, prevList, viewWidth, viewHeight) {
+        if (this.__firstTimePaint) {
+            this.__firstTimePaint = false;
+            return null;
+        }
+        var mergedRepaintRects = [];
+        var maxRepaintRectCount = this.maxRepaintRectCount;
+        var full = false;
+        var pendingRect = new BoundingRect(0, 0, 0, 0);
+        function addRectToMergePool(rect) {
+            if (!rect.isFinite() || rect.isZero()) {
+                return;
+            }
+            if (mergedRepaintRects.length === 0) {
+                var boundingRect = new BoundingRect(0, 0, 0, 0);
+                boundingRect.copy(rect);
+                mergedRepaintRects.push(boundingRect);
+            }
+            else {
+                var isMerged = false;
+                var minDeltaArea = Infinity;
+                var bestRectToMergeIdx = 0;
+                for (var i = 0; i < mergedRepaintRects.length; ++i) {
+                    var mergedRect = mergedRepaintRects[i];
+                    if (mergedRect.intersect(rect)) {
+                        var pendingRect_1 = new BoundingRect(0, 0, 0, 0);
+                        pendingRect_1.copy(mergedRect);
+                        pendingRect_1.union(rect);
+                        mergedRepaintRects[i] = pendingRect_1;
+                        isMerged = true;
+                        break;
+                    }
+                    else if (full) {
+                        pendingRect.copy(rect);
+                        pendingRect.union(mergedRect);
+                        var aArea = rect.width * rect.height;
+                        var bArea = mergedRect.width * mergedRect.height;
+                        var pendingArea = pendingRect.width * pendingRect.height;
+                        var deltaArea = pendingArea - aArea - bArea;
+                        if (deltaArea < minDeltaArea) {
+                            minDeltaArea = deltaArea;
+                            bestRectToMergeIdx = i;
+                        }
+                    }
+                }
+                if (full) {
+                    mergedRepaintRects[bestRectToMergeIdx].union(rect);
+                    isMerged = true;
+                }
+                if (!isMerged) {
+                    var boundingRect = new BoundingRect(0, 0, 0, 0);
+                    boundingRect.copy(rect);
+                    mergedRepaintRects.push(boundingRect);
+                }
+                if (!full) {
+                    full = mergedRepaintRects.length >= maxRepaintRectCount;
+                }
+            }
+        }
+        for (var i = this.__startIndex; i < this.__endIndex; ++i) {
+            var el = displayList[i];
+            if (el) {
+                var shouldPaint = el.shouldBePainted(viewWidth, viewHeight, true, true);
+                var prevRect = el.__isRendered && ((el.__dirty & REDRAW_BIT) || !shouldPaint)
+                    ? el.getPrevPaintRect()
+                    : null;
+                if (prevRect) {
+                    addRectToMergePool(prevRect);
+                }
+                var curRect = shouldPaint && ((el.__dirty & REDRAW_BIT) || !el.__isRendered)
+                    ? el.getPaintRect()
+                    : null;
+                if (curRect) {
+                    addRectToMergePool(curRect);
+                }
+            }
+        }
+        for (var i = this.__prevStartIndex; i < this.__prevEndIndex; ++i) {
+            var el = prevList[i];
+            var shouldPaint = el.shouldBePainted(viewWidth, viewHeight, true, true);
+            if (el && (!shouldPaint || !el.__zr) && el.__isRendered) {
+                var prevRect = el.getPrevPaintRect();
+                if (prevRect) {
+                    addRectToMergePool(prevRect);
+                }
+            }
+        }
+        var hasIntersections;
+        do {
+            hasIntersections = false;
+            for (var i = 0; i < mergedRepaintRects.length;) {
+                if (mergedRepaintRects[i].isZero()) {
+                    mergedRepaintRects.splice(i, 1);
+                    continue;
+                }
+                for (var j = i + 1; j < mergedRepaintRects.length;) {
+                    if (mergedRepaintRects[i].intersect(mergedRepaintRects[j])) {
+                        hasIntersections = true;
+                        mergedRepaintRects[i].union(mergedRepaintRects[j]);
+                        mergedRepaintRects.splice(j, 1);
+                    }
+                    else {
+                        j++;
+                    }
+                }
+                i++;
+            }
+        } while (hasIntersections);
+        this._paintRects = mergedRepaintRects;
+        return mergedRepaintRects;
+    };
+    Layer.prototype.debugGetPaintRects = function () {
+        return (this._paintRects || []).slice();
+    };
+    Layer.prototype.resize = function (width, height) {
+        var dpr = this.dpr;
+        var dom = this.dom;
+        var domStyle = dom.style;
+        var domBack = this.domBack;
+        if (domStyle) {
+            domStyle.width = width + 'px';
+            domStyle.height = height + 'px';
+        }
+        dom.width = width * dpr;
+        dom.height = height * dpr;
+        if (domBack) {
+            domBack.width = width * dpr;
+            domBack.height = height * dpr;
+            if (dpr !== 1) {
+                this.ctxBack.scale(dpr, dpr);
+            }
+        }
+    };
+    Layer.prototype.clear = function (clearAll, clearColor, repaintRects) {
+        var dom = this.dom;
+        var ctx = this.ctx;
+        var width = dom.width;
+        var height = dom.height;
+        clearColor = clearColor || this.clearColor;
+        var haveMotionBLur = this.motionBlur && !clearAll;
+        var lastFrameAlpha = this.lastFrameAlpha;
+        var dpr = this.dpr;
+        var self = this;
+        if (haveMotionBLur) {
+            if (!this.domBack) {
+                this.createBackBuffer();
+            }
+            this.ctxBack.globalCompositeOperation = 'copy';
+            this.ctxBack.drawImage(dom, 0, 0, width / dpr, height / dpr);
+        }
+        var domBack = this.domBack;
+        function doClear(x, y, width, height) {
+            ctx.clearRect(x, y, width, height);
+            if (clearColor && clearColor !== 'transparent') {
+                var clearColorGradientOrPattern = void 0;
+                if (util.isGradientObject(clearColor)) {
+                    clearColorGradientOrPattern = clearColor.__canvasGradient
+                        || getCanvasGradient(ctx, clearColor, {
+                            x: 0,
+                            y: 0,
+                            width: width,
+                            height: height
+                        });
+                    clearColor.__canvasGradient = clearColorGradientOrPattern;
+                }
+                else if (util.isImagePatternObject(clearColor)) {
+                    clearColorGradientOrPattern = createCanvasPattern(ctx, clearColor, {
+                        dirty: function () {
+                            self.setUnpainted();
+                            self.__painter.refresh();
+                        }
+                    });
+                }
+                ctx.save();
+                ctx.fillStyle = clearColorGradientOrPattern || clearColor;
+                ctx.fillRect(x, y, width, height);
+                ctx.restore();
+            }
+            if (haveMotionBLur) {
+                ctx.save();
+                ctx.globalAlpha = lastFrameAlpha;
+                ctx.drawImage(domBack, x, y, width, height);
+                ctx.restore();
+            }
+        }
+        ;
+        if (!repaintRects || haveMotionBLur) {
+            doClear(0, 0, width, height);
+        }
+        else if (repaintRects.length) {
+            util.each(repaintRects, function (rect) {
+                doClear(rect.x * dpr, rect.y * dpr, rect.width * dpr, rect.height * dpr);
+            });
+        }
+    };
+    return Layer;
+}(Eventful));
+export default Layer;

uni-demo/node_modules/zrender/lib/canvas/Painter.d.ts

@@ -0,0 +1,72 @@
+import Layer, { LayerConfig } from './Layer';
+import Displayable from '../graphic/Displayable';
+import { GradientObject } from '../graphic/Gradient';
+import { ImagePatternObject } from '../graphic/Pattern';
+import Storage from '../Storage';
+import { PainterBase } from '../PainterBase';
+interface CanvasPainterOption {
+    devicePixelRatio?: number;
+    width?: number | string;
+    height?: number | string;
+    useDirtyRect?: boolean;
+}
+export default class CanvasPainter implements PainterBase {
+    type: string;
+    root: HTMLElement;
+    dpr: number;
+    storage: Storage;
+    private _singleCanvas;
+    private _opts;
+    private _zlevelList;
+    private _prevDisplayList;
+    private _layers;
+    private _layerConfig;
+    private _needsManuallyCompositing;
+    private _width;
+    private _height;
+    private _domRoot;
+    private _hoverlayer;
+    private _redrawId;
+    private _backgroundColor;
+    constructor(root: HTMLElement, storage: Storage, opts: CanvasPainterOption, id: number);
+    getType(): string;
+    isSingleCanvas(): boolean;
+    getViewportRoot(): HTMLElement;
+    getViewportRootOffset(): {
+        offsetLeft: number;
+        offsetTop: number;
+    };
+    refresh(paintAll?: boolean): this;
+    refreshHover(): void;
+    private _paintHoverList;
+    getHoverLayer(): Layer;
+    paintOne(ctx: CanvasRenderingContext2D, el: Displayable): void;
+    private _paintList;
+    private _compositeManually;
+    private _doPaintList;
+    private _doPaintEl;
+    getLayer(zlevel: number, virtual?: boolean): Layer;
+    insertLayer(zlevel: number, layer: Layer): void;
+    eachLayer<T>(cb: (this: T, layer: Layer, z: number) => void, context?: T): void;
+    eachBuiltinLayer<T>(cb: (this: T, layer: Layer, z: number) => void, context?: T): void;
+    eachOtherLayer<T>(cb: (this: T, layer: Layer, z: number) => void, context?: T): void;
+    getLayers(): {
+        [key: number]: Layer;
+    };
+    _updateLayerStatus(list: Displayable[]): void;
+    clear(): this;
+    _clearLayer(layer: Layer): void;
+    setBackgroundColor(backgroundColor: string | GradientObject | ImagePatternObject): void;
+    configLayer(zlevel: number, config: LayerConfig): void;
+    delLayer(zlevel: number): void;
+    resize(width?: number | string, height?: number | string): this;
+    clearLayer(zlevel: number): void;
+    dispose(): void;
+    getRenderedCanvas(opts?: {
+        backgroundColor?: string | GradientObject | ImagePatternObject;
+        pixelRatio?: number;
+    }): HTMLCanvasElement;
+    getWidth(): number;
+    getHeight(): number;
+}
+export {};

uni-demo/node_modules/zrender/lib/canvas/Painter.js

@@ -0,0 +1,641 @@
+import { devicePixelRatio } from '../config.js';
+import * as util from '../core/util.js';
+import Layer from './Layer.js';
+import requestAnimationFrame from '../animation/requestAnimationFrame.js';
+import env from '../core/env.js';
+import { brush, brushSingle } from './graphic.js';
+import { REDRAW_BIT } from '../graphic/constants.js';
+import { getSize } from './helper.js';
+var HOVER_LAYER_ZLEVEL = 1e5;
+var CANVAS_ZLEVEL = 314159;
+var EL_AFTER_INCREMENTAL_INC = 0.01;
+var INCREMENTAL_INC = 0.001;
+function isLayerValid(layer) {
+    if (!layer) {
+        return false;
+    }
+    if (layer.__builtin__) {
+        return true;
+    }
+    if (typeof (layer.resize) !== 'function'
+        || typeof (layer.refresh) !== 'function') {
+        return false;
+    }
+    return true;
+}
+function createRoot(width, height) {
+    var domRoot = document.createElement('div');
+    domRoot.style.cssText = [
+        'position:relative',
+        'width:' + width + 'px',
+        'height:' + height + 'px',
+        'padding:0',
+        'margin:0',
+        'border-width:0'
+    ].join(';') + ';';
+    return domRoot;
+}
+var CanvasPainter = (function () {
+    function CanvasPainter(root, storage, opts, id) {
+        this.type = 'canvas';
+        this._zlevelList = [];
+        this._prevDisplayList = [];
+        this._layers = {};
+        this._layerConfig = {};
+        this._needsManuallyCompositing = false;
+        this.type = 'canvas';
+        var singleCanvas = !root.nodeName
+            || root.nodeName.toUpperCase() === 'CANVAS';
+        this._opts = opts = util.extend({}, opts || {});
+        this.dpr = opts.devicePixelRatio || devicePixelRatio;
+        this._singleCanvas = singleCanvas;
+        this.root = root;
+        var rootStyle = root.style;
+        if (rootStyle) {
+            util.disableUserSelect(root);
+            root.innerHTML = '';
+        }
+        this.storage = storage;
+        var zlevelList = this._zlevelList;
+        this._prevDisplayList = [];
+        var layers = this._layers;
+        if (!singleCanvas) {
+            this._width = getSize(root, 0, opts);
+            this._height = getSize(root, 1, opts);
+            var domRoot = this._domRoot = createRoot(this._width, this._height);
+            root.appendChild(domRoot);
+        }
+        else {
+            var rootCanvas = root;
+            var width = rootCanvas.width;
+            var height = rootCanvas.height;
+            if (opts.width != null) {
+                width = opts.width;
+            }
+            if (opts.height != null) {
+                height = opts.height;
+            }
+            this.dpr = opts.devicePixelRatio || 1;
+            rootCanvas.width = width * this.dpr;
+            rootCanvas.height = height * this.dpr;
+            this._width = width;
+            this._height = height;
+            var mainLayer = new Layer(rootCanvas, this, this.dpr);
+            mainLayer.__builtin__ = true;
+            mainLayer.initContext();
+            layers[CANVAS_ZLEVEL] = mainLayer;
+            mainLayer.zlevel = CANVAS_ZLEVEL;
+            zlevelList.push(CANVAS_ZLEVEL);
+            this._domRoot = root;
+        }
+    }
+    CanvasPainter.prototype.getType = function () {
+        return 'canvas';
+    };
+    CanvasPainter.prototype.isSingleCanvas = function () {
+        return this._singleCanvas;
+    };
+    CanvasPainter.prototype.getViewportRoot = function () {
+        return this._domRoot;
+    };
+    CanvasPainter.prototype.getViewportRootOffset = function () {
+        var viewportRoot = this.getViewportRoot();
+        if (viewportRoot) {
+            return {
+                offsetLeft: viewportRoot.offsetLeft || 0,
+                offsetTop: viewportRoot.offsetTop || 0
+            };
+        }
+    };
+    CanvasPainter.prototype.refresh = function (paintAll) {
+        var list = this.storage.getDisplayList(true);
+        var prevList = this._prevDisplayList;
+        var zlevelList = this._zlevelList;
+        this._redrawId = Math.random();
+        this._paintList(list, prevList, paintAll, this._redrawId);
+        for (var i = 0; i < zlevelList.length; i++) {
+            var z = zlevelList[i];
+            var layer = this._layers[z];
+            if (!layer.__builtin__ && layer.refresh) {
+                var clearColor = i === 0 ? this._backgroundColor : null;
+                layer.refresh(clearColor);
+            }
+        }
+        if (this._opts.useDirtyRect) {
+            this._prevDisplayList = list.slice();
+        }
+        return this;
+    };
+    CanvasPainter.prototype.refreshHover = function () {
+        this._paintHoverList(this.storage.getDisplayList(false));
+    };
+    CanvasPainter.prototype._paintHoverList = function (list) {
+        var len = list.length;
+        var hoverLayer = this._hoverlayer;
+        hoverLayer && hoverLayer.clear();
+        if (!len) {
+            return;
+        }
+        var scope = {
+            inHover: true,
+            viewWidth: this._width,
+            viewHeight: this._height
+        };
+        var ctx;
+        for (var i = 0; i < len; i++) {
+            var el = list[i];
+            if (el.__inHover) {
+                if (!hoverLayer) {
+                    hoverLayer = this._hoverlayer = this.getLayer(HOVER_LAYER_ZLEVEL);
+                }
+                if (!ctx) {
+                    ctx = hoverLayer.ctx;
+                    ctx.save();
+                }
+                brush(ctx, el, scope, i === len - 1);
+            }
+        }
+        if (ctx) {
+            ctx.restore();
+        }
+    };
+    CanvasPainter.prototype.getHoverLayer = function () {
+        return this.getLayer(HOVER_LAYER_ZLEVEL);
+    };
+    CanvasPainter.prototype.paintOne = function (ctx, el) {
+        brushSingle(ctx, el);
+    };
+    CanvasPainter.prototype._paintList = function (list, prevList, paintAll, redrawId) {
+        if (this._redrawId !== redrawId) {
+            return;
+        }
+        paintAll = paintAll || false;
+        this._updateLayerStatus(list);
+        var _a = this._doPaintList(list, prevList, paintAll), finished = _a.finished, needsRefreshHover = _a.needsRefreshHover;
+        if (this._needsManuallyCompositing) {
+            this._compositeManually();
+        }
+        if (needsRefreshHover) {
+            this._paintHoverList(list);
+        }
+        if (!finished) {
+            var self_1 = this;
+            requestAnimationFrame(function () {
+                self_1._paintList(list, prevList, paintAll, redrawId);
+            });
+        }
+        else {
+            this.eachLayer(function (layer) {
+                layer.afterBrush && layer.afterBrush();
+            });
+        }
+    };
+    CanvasPainter.prototype._compositeManually = function () {
+        var ctx = this.getLayer(CANVAS_ZLEVEL).ctx;
+        var width = this._domRoot.width;
+        var height = this._domRoot.height;
+        ctx.clearRect(0, 0, width, height);
+        this.eachBuiltinLayer(function (layer) {
+            if (layer.virtual) {
+                ctx.drawImage(layer.dom, 0, 0, width, height);
+            }
+        });
+    };
+    CanvasPainter.prototype._doPaintList = function (list, prevList, paintAll) {
+        var _this = this;
+        var layerList = [];
+        var useDirtyRect = this._opts.useDirtyRect;
+        for (var zi = 0; zi < this._zlevelList.length; zi++) {
+            var zlevel = this._zlevelList[zi];
+            var layer = this._layers[zlevel];
+            if (layer.__builtin__
+                && layer !== this._hoverlayer
+                && (layer.__dirty || paintAll)) {
+                layerList.push(layer);
+            }
+        }
+        var finished = true;
+        var needsRefreshHover = false;
+        var _loop_1 = function (k) {
+            var layer = layerList[k];
+            var ctx = layer.ctx;
+            var repaintRects = useDirtyRect
+                && layer.createRepaintRects(list, prevList, this_1._width, this_1._height);
+            var start = paintAll ? layer.__startIndex : layer.__drawIndex;
+            var useTimer = !paintAll && layer.incremental && Date.now;
+            var startTime = useTimer && Date.now();
+            var clearColor = layer.zlevel === this_1._zlevelList[0]
+                ? this_1._backgroundColor : null;
+            if (layer.__startIndex === layer.__endIndex) {
+                layer.clear(false, clearColor, repaintRects);
+            }
+            else if (start === layer.__startIndex) {
+                var firstEl = list[start];
+                if (!firstEl.incremental || !firstEl.notClear || paintAll) {
+                    layer.clear(false, clearColor, repaintRects);
+                }
+            }
+            if (start === -1) {
+                console.error('For some unknown reason. drawIndex is -1');
+                start = layer.__startIndex;
+            }
+            var i;
+            var repaint = function (repaintRect) {
+                var scope = {
+                    inHover: false,
+                    allClipped: false,
+                    prevEl: null,
+                    viewWidth: _this._width,
+                    viewHeight: _this._height
+                };
+                for (i = start; i < layer.__endIndex; i++) {
+                    var el = list[i];
+                    if (el.__inHover) {
+                        needsRefreshHover = true;
+                    }
+                    _this._doPaintEl(el, layer, useDirtyRect, repaintRect, scope, i === layer.__endIndex - 1);
+                    if (useTimer) {
+                        var dTime = Date.now() - startTime;
+                        if (dTime > 15) {
+                            break;
+                        }
+                    }
+                }
+                if (scope.prevElClipPaths) {
+                    ctx.restore();
+                }
+            };
+            if (repaintRects) {
+                if (repaintRects.length === 0) {
+                    i = layer.__endIndex;
+                }
+                else {
+                    var dpr = this_1.dpr;
+                    for (var r = 0; r < repaintRects.length; ++r) {
+                        var rect = repaintRects[r];
+                        ctx.save();
+                        ctx.beginPath();
+                        ctx.rect(rect.x * dpr, rect.y * dpr, rect.width * dpr, rect.height * dpr);
+                        ctx.clip();
+                        repaint(rect);
+                        ctx.restore();
+                    }
+                }
+            }
+            else {
+                ctx.save();
+                repaint();
+                ctx.restore();
+            }
+            layer.__drawIndex = i;
+            if (layer.__drawIndex < layer.__endIndex) {
+                finished = false;
+            }
+        };
+        var this_1 = this;
+        for (var k = 0; k < layerList.length; k++) {
+            _loop_1(k);
+        }
+        if (env.wxa) {
+            util.each(this._layers, function (layer) {
+                if (layer && layer.ctx && layer.ctx.draw) {
+                    layer.ctx.draw();
+                }
+            });
+        }
+        return {
+            finished: finished,
+            needsRefreshHover: needsRefreshHover
+        };
+    };
+    CanvasPainter.prototype._doPaintEl = function (el, currentLayer, useDirtyRect, repaintRect, scope, isLast) {
+        var ctx = currentLayer.ctx;
+        if (useDirtyRect) {
+            var paintRect = el.getPaintRect();
+            if (!repaintRect || paintRect && paintRect.intersect(repaintRect)) {
+                brush(ctx, el, scope, isLast);
+                el.setPrevPaintRect(paintRect);
+            }
+        }
+        else {
+            brush(ctx, el, scope, isLast);
+        }
+    };
+    CanvasPainter.prototype.getLayer = function (zlevel, virtual) {
+        if (this._singleCanvas && !this._needsManuallyCompositing) {
+            zlevel = CANVAS_ZLEVEL;
+        }
+        var layer = this._layers[zlevel];
+        if (!layer) {
+            layer = new Layer('zr_' + zlevel, this, this.dpr);
+            layer.zlevel = zlevel;
+            layer.__builtin__ = true;
+            if (this._layerConfig[zlevel]) {
+                util.merge(layer, this._layerConfig[zlevel], true);
+            }
+            else if (this._layerConfig[zlevel - EL_AFTER_INCREMENTAL_INC]) {
+                util.merge(layer, this._layerConfig[zlevel - EL_AFTER_INCREMENTAL_INC], true);
+            }
+            if (virtual) {
+                layer.virtual = virtual;
+            }
+            this.insertLayer(zlevel, layer);
+            layer.initContext();
+        }
+        return layer;
+    };
+    CanvasPainter.prototype.insertLayer = function (zlevel, layer) {
+        var layersMap = this._layers;
+        var zlevelList = this._zlevelList;
+        var len = zlevelList.length;
+        var domRoot = this._domRoot;
+        var prevLayer = null;
+        var i = -1;
+        if (layersMap[zlevel]) {
+            if (process.env.NODE_ENV !== 'production') {
+                util.logError('ZLevel ' + zlevel + ' has been used already');
+            }
+            return;
+        }
+        if (!isLayerValid(layer)) {
+            if (process.env.NODE_ENV !== 'production') {
+                util.logError('Layer of zlevel ' + zlevel + ' is not valid');
+            }
+            return;
+        }
+        if (len > 0 && zlevel > zlevelList[0]) {
+            for (i = 0; i < len - 1; i++) {
+                if (zlevelList[i] < zlevel
+                    && zlevelList[i + 1] > zlevel) {
+                    break;
+                }
+            }
+            prevLayer = layersMap[zlevelList[i]];
+        }
+        zlevelList.splice(i + 1, 0, zlevel);
+        layersMap[zlevel] = layer;
+        if (!layer.virtual) {
+            if (prevLayer) {
+                var prevDom = prevLayer.dom;
+                if (prevDom.nextSibling) {
+                    domRoot.insertBefore(layer.dom, prevDom.nextSibling);
+                }
+                else {
+                    domRoot.appendChild(layer.dom);
+                }
+            }
+            else {
+                if (domRoot.firstChild) {
+                    domRoot.insertBefore(layer.dom, domRoot.firstChild);
+                }
+                else {
+                    domRoot.appendChild(layer.dom);
+                }
+            }
+        }
+        layer.__painter = this;
+    };
+    CanvasPainter.prototype.eachLayer = function (cb, context) {
+        var zlevelList = this._zlevelList;
+        for (var i = 0; i < zlevelList.length; i++) {
+            var z = zlevelList[i];
+            cb.call(context, this._layers[z], z);
+        }
+    };
+    CanvasPainter.prototype.eachBuiltinLayer = function (cb, context) {
+        var zlevelList = this._zlevelList;
+        for (var i = 0; i < zlevelList.length; i++) {
+            var z = zlevelList[i];
+            var layer = this._layers[z];
+            if (layer.__builtin__) {
+                cb.call(context, layer, z);
+            }
+        }
+    };
+    CanvasPainter.prototype.eachOtherLayer = function (cb, context) {
+        var zlevelList = this._zlevelList;
+        for (var i = 0; i < zlevelList.length; i++) {
+            var z = zlevelList[i];
+            var layer = this._layers[z];
+            if (!layer.__builtin__) {
+                cb.call(context, layer, z);
+            }
+        }
+    };
+    CanvasPainter.prototype.getLayers = function () {
+        return this._layers;
+    };
+    CanvasPainter.prototype._updateLayerStatus = function (list) {
+        this.eachBuiltinLayer(function (layer, z) {
+            layer.__dirty = layer.__used = false;
+        });
+        function updatePrevLayer(idx) {
+            if (prevLayer) {
+                if (prevLayer.__endIndex !== idx) {
+                    prevLayer.__dirty = true;
+                }
+                prevLayer.__endIndex = idx;
+            }
+        }
+        if (this._singleCanvas) {
+            for (var i_1 = 1; i_1 < list.length; i_1++) {
+                var el = list[i_1];
+                if (el.zlevel !== list[i_1 - 1].zlevel || el.incremental) {
+                    this._needsManuallyCompositing = true;
+                    break;
+                }
+            }
+        }
+        var prevLayer = null;
+        var incrementalLayerCount = 0;
+        var prevZlevel;
+        var i;
+        for (i = 0; i < list.length; i++) {
+            var el = list[i];
+            var zlevel = el.zlevel;
+            var layer = void 0;
+            if (prevZlevel !== zlevel) {
+                prevZlevel = zlevel;
+                incrementalLayerCount = 0;
+            }
+            if (el.incremental) {
+                layer = this.getLayer(zlevel + INCREMENTAL_INC, this._needsManuallyCompositing);
+                layer.incremental = true;
+                incrementalLayerCount = 1;
+            }
+            else {
+                layer = this.getLayer(zlevel + (incrementalLayerCount > 0 ? EL_AFTER_INCREMENTAL_INC : 0), this._needsManuallyCompositing);
+            }
+            if (!layer.__builtin__) {
+                util.logError('ZLevel ' + zlevel + ' has been used by unkown layer ' + layer.id);
+            }
+            if (layer !== prevLayer) {
+                layer.__used = true;
+                if (layer.__startIndex !== i) {
+                    layer.__dirty = true;
+                }
+                layer.__startIndex = i;
+                if (!layer.incremental) {
+                    layer.__drawIndex = i;
+                }
+                else {
+                    layer.__drawIndex = -1;
+                }
+                updatePrevLayer(i);
+                prevLayer = layer;
+            }
+            if ((el.__dirty & REDRAW_BIT) && !el.__inHover) {
+                layer.__dirty = true;
+                if (layer.incremental && layer.__drawIndex < 0) {
+                    layer.__drawIndex = i;
+                }
+            }
+        }
+        updatePrevLayer(i);
+        this.eachBuiltinLayer(function (layer, z) {
+            if (!layer.__used && layer.getElementCount() > 0) {
+                layer.__dirty = true;
+                layer.__startIndex = layer.__endIndex = layer.__drawIndex = 0;
+            }
+            if (layer.__dirty && layer.__drawIndex < 0) {
+                layer.__drawIndex = layer.__startIndex;
+            }
+        });
+    };
+    CanvasPainter.prototype.clear = function () {
+        this.eachBuiltinLayer(this._clearLayer);
+        return this;
+    };
+    CanvasPainter.prototype._clearLayer = function (layer) {
+        layer.clear();
+    };
+    CanvasPainter.prototype.setBackgroundColor = function (backgroundColor) {
+        this._backgroundColor = backgroundColor;
+        util.each(this._layers, function (layer) {
+            layer.setUnpainted();
+        });
+    };
+    CanvasPainter.prototype.configLayer = function (zlevel, config) {
+        if (config) {
+            var layerConfig = this._layerConfig;
+            if (!layerConfig[zlevel]) {
+                layerConfig[zlevel] = config;
+            }
+            else {
+                util.merge(layerConfig[zlevel], config, true);
+            }
+            for (var i = 0; i < this._zlevelList.length; i++) {
+                var _zlevel = this._zlevelList[i];
+                if (_zlevel === zlevel || _zlevel === zlevel + EL_AFTER_INCREMENTAL_INC) {
+                    var layer = this._layers[_zlevel];
+                    util.merge(layer, layerConfig[zlevel], true);
+                }
+            }
+        }
+    };
+    CanvasPainter.prototype.delLayer = function (zlevel) {
+        var layers = this._layers;
+        var zlevelList = this._zlevelList;
+        var layer = layers[zlevel];
+        if (!layer) {
+            return;
+        }
+        layer.dom.parentNode.removeChild(layer.dom);
+        delete layers[zlevel];
+        zlevelList.splice(util.indexOf(zlevelList, zlevel), 1);
+    };
+    CanvasPainter.prototype.resize = function (width, height) {
+        if (!this._domRoot.style) {
+            if (width == null || height == null) {
+                return;
+            }
+            this._width = width;
+            this._height = height;
+            this.getLayer(CANVAS_ZLEVEL).resize(width, height);
+        }
+        else {
+            var domRoot = this._domRoot;
+            domRoot.style.display = 'none';
+            var opts = this._opts;
+            var root = this.root;
+            width != null && (opts.width = width);
+            height != null && (opts.height = height);
+            width = getSize(root, 0, opts);
+            height = getSize(root, 1, opts);
+            domRoot.style.display = '';
+            if (this._width !== width || height !== this._height) {
+                domRoot.style.width = width + 'px';
+                domRoot.style.height = height + 'px';
+                for (var id in this._layers) {
+                    if (this._layers.hasOwnProperty(id)) {
+                        this._layers[id].resize(width, height);
+                    }
+                }
+                this.refresh(true);
+            }
+            this._width = width;
+            this._height = height;
+        }
+        return this;
+    };
+    CanvasPainter.prototype.clearLayer = function (zlevel) {
+        var layer = this._layers[zlevel];
+        if (layer) {
+            layer.clear();
+        }
+    };
+    CanvasPainter.prototype.dispose = function () {
+        this.root.innerHTML = '';
+        this.root =
+            this.storage =
+                this._domRoot =
+                    this._layers = null;
+    };
+    CanvasPainter.prototype.getRenderedCanvas = function (opts) {
+        opts = opts || {};
+        if (this._singleCanvas && !this._compositeManually) {
+            return this._layers[CANVAS_ZLEVEL].dom;
+        }
+        var imageLayer = new Layer('image', this, opts.pixelRatio || this.dpr);
+        imageLayer.initContext();
+        imageLayer.clear(false, opts.backgroundColor || this._backgroundColor);
+        var ctx = imageLayer.ctx;
+        if (opts.pixelRatio <= this.dpr) {
+            this.refresh();
+            var width_1 = imageLayer.dom.width;
+            var height_1 = imageLayer.dom.height;
+            this.eachLayer(function (layer) {
+                if (layer.__builtin__) {
+                    ctx.drawImage(layer.dom, 0, 0, width_1, height_1);
+                }
+                else if (layer.renderToCanvas) {
+                    ctx.save();
+                    layer.renderToCanvas(ctx);
+                    ctx.restore();
+                }
+            });
+        }
+        else {
+            var scope = {
+                inHover: false,
+                viewWidth: this._width,
+                viewHeight: this._height
+            };
+            var displayList = this.storage.getDisplayList(true);
+            for (var i = 0, len = displayList.length; i < len; i++) {
+                var el = displayList[i];
+                brush(ctx, el, scope, i === len - 1);
+            }
+        }
+        return imageLayer.dom;
+    };
+    CanvasPainter.prototype.getWidth = function () {
+        return this._width;
+    };
+    CanvasPainter.prototype.getHeight = function () {
+        return this._height;
+    };
+    return CanvasPainter;
+}());
+export default CanvasPainter;
+;

uni-demo/node_modules/zrender/lib/canvas/canvas.d.ts

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

uni-demo/node_modules/zrender/lib/canvas/canvas.js

@@ -0,0 +1,3 @@
+import { registerPainter } from '../zrender.js';
+import Painter from './Painter.js';
+registerPainter('canvas', Painter);

uni-demo/node_modules/zrender/lib/canvas/dashStyle.d.ts

@@ -0,0 +1,4 @@
+import Path from '../graphic/Path';
+import TSpan from '../graphic/TSpan';
+export declare function normalizeLineDash(lineType: any, lineWidth?: number): number[] | false;
+export declare function getLineDash(el: Path | TSpan): [number[] | false, number];

uni-demo/node_modules/zrender/lib/canvas/dashStyle.js

@@ -0,0 +1,27 @@
+import { isArray, isNumber, map } from '../core/util.js';
+export function normalizeLineDash(lineType, lineWidth) {
+    if (!lineType || lineType === 'solid' || !(lineWidth > 0)) {
+        return null;
+    }
+    return lineType === 'dashed'
+        ? [4 * lineWidth, 2 * lineWidth]
+        : lineType === 'dotted'
+            ? [lineWidth]
+            : isNumber(lineType)
+                ? [lineType] : isArray(lineType) ? lineType : null;
+}
+export function getLineDash(el) {
+    var style = el.style;
+    var lineDash = style.lineDash && style.lineWidth > 0 && normalizeLineDash(style.lineDash, style.lineWidth);
+    var lineDashOffset = style.lineDashOffset;
+    if (lineDash) {
+        var lineScale_1 = (style.strokeNoScale && el.getLineScale) ? el.getLineScale() : 1;
+        if (lineScale_1 && lineScale_1 !== 1) {
+            lineDash = map(lineDash, function (rawVal) {
+                return rawVal / lineScale_1;
+            });
+            lineDashOffset /= lineScale_1;
+        }
+    }
+    return [lineDash, lineDashOffset];
+}

uni-demo/node_modules/zrender/lib/canvas/graphic.d.ts

@@ -0,0 +1,19 @@
+import Displayable from '../graphic/Displayable';
+import { ImagePatternObject } from '../graphic/Pattern';
+import Path from '../graphic/Path';
+export declare function createCanvasPattern(this: void, ctx: CanvasRenderingContext2D, pattern: ImagePatternObject, el: {
+    dirty: () => void;
+}): CanvasPattern;
+export declare type BrushScope = {
+    inHover: boolean;
+    viewWidth: number;
+    viewHeight: number;
+    prevElClipPaths?: Path[];
+    prevEl?: Displayable;
+    allClipped?: boolean;
+    batchFill?: string;
+    batchStroke?: string;
+    lastDrawType?: number;
+};
+export declare function brushSingle(ctx: CanvasRenderingContext2D, el: Displayable): void;
+export declare function brush(ctx: CanvasRenderingContext2D, el: Displayable, scope: BrushScope, isLast: boolean): void;

uni-demo/node_modules/zrender/lib/canvas/graphic.js

@@ -0,0 +1,558 @@
+import { DEFAULT_COMMON_STYLE } from '../graphic/Displayable.js';
+import PathProxy from '../core/PathProxy.js';
+import { createOrUpdateImage, isImageReady } from '../graphic/helper/image.js';
+import { getCanvasGradient, isClipPathChanged } from './helper.js';
+import Path from '../graphic/Path.js';
+import ZRImage from '../graphic/Image.js';
+import TSpan from '../graphic/TSpan.js';
+import { RADIAN_TO_DEGREE } from '../core/util.js';
+import { getLineDash } from './dashStyle.js';
+import { REDRAW_BIT, SHAPE_CHANGED_BIT } from '../graphic/constants.js';
+import { DEFAULT_FONT } from '../core/platform.js';
+var pathProxyForDraw = new PathProxy(true);
+function styleHasStroke(style) {
+    var stroke = style.stroke;
+    return !(stroke == null || stroke === 'none' || !(style.lineWidth > 0));
+}
+function isValidStrokeFillStyle(strokeOrFill) {
+    return typeof strokeOrFill === 'string' && strokeOrFill !== 'none';
+}
+function styleHasFill(style) {
+    var fill = style.fill;
+    return fill != null && fill !== 'none';
+}
+function doFillPath(ctx, style) {
+    if (style.fillOpacity != null && style.fillOpacity !== 1) {
+        var originalGlobalAlpha = ctx.globalAlpha;
+        ctx.globalAlpha = style.fillOpacity * style.opacity;
+        ctx.fill();
+        ctx.globalAlpha = originalGlobalAlpha;
+    }
+    else {
+        ctx.fill();
+    }
+}
+function doStrokePath(ctx, style) {
+    if (style.strokeOpacity != null && style.strokeOpacity !== 1) {
+        var originalGlobalAlpha = ctx.globalAlpha;
+        ctx.globalAlpha = style.strokeOpacity * style.opacity;
+        ctx.stroke();
+        ctx.globalAlpha = originalGlobalAlpha;
+    }
+    else {
+        ctx.stroke();
+    }
+}
+export function createCanvasPattern(ctx, pattern, el) {
+    var image = createOrUpdateImage(pattern.image, pattern.__image, el);
+    if (isImageReady(image)) {
+        var canvasPattern = ctx.createPattern(image, pattern.repeat || 'repeat');
+        if (typeof DOMMatrix === 'function'
+            && canvasPattern
+            && canvasPattern.setTransform) {
+            var matrix = new DOMMatrix();
+            matrix.translateSelf((pattern.x || 0), (pattern.y || 0));
+            matrix.rotateSelf(0, 0, (pattern.rotation || 0) * RADIAN_TO_DEGREE);
+            matrix.scaleSelf((pattern.scaleX || 1), (pattern.scaleY || 1));
+            canvasPattern.setTransform(matrix);
+        }
+        return canvasPattern;
+    }
+}
+function brushPath(ctx, el, style, inBatch) {
+    var _a;
+    var hasStroke = styleHasStroke(style);
+    var hasFill = styleHasFill(style);
+    var strokePercent = style.strokePercent;
+    var strokePart = strokePercent < 1;
+    var firstDraw = !el.path;
+    if ((!el.silent || strokePart) && firstDraw) {
+        el.createPathProxy();
+    }
+    var path = el.path || pathProxyForDraw;
+    var dirtyFlag = el.__dirty;
+    if (!inBatch) {
+        var fill = style.fill;
+        var stroke = style.stroke;
+        var hasFillGradient = hasFill && !!fill.colorStops;
+        var hasStrokeGradient = hasStroke && !!stroke.colorStops;
+        var hasFillPattern = hasFill && !!fill.image;
+        var hasStrokePattern = hasStroke && !!stroke.image;
+        var fillGradient = void 0;
+        var strokeGradient = void 0;
+        var fillPattern = void 0;
+        var strokePattern = void 0;
+        var rect = void 0;
+        if (hasFillGradient || hasStrokeGradient) {
+            rect = el.getBoundingRect();
+        }
+        if (hasFillGradient) {
+            fillGradient = dirtyFlag
+                ? getCanvasGradient(ctx, fill, rect)
+                : el.__canvasFillGradient;
+            el.__canvasFillGradient = fillGradient;
+        }
+        if (hasStrokeGradient) {
+            strokeGradient = dirtyFlag
+                ? getCanvasGradient(ctx, stroke, rect)
+                : el.__canvasStrokeGradient;
+            el.__canvasStrokeGradient = strokeGradient;
+        }
+        if (hasFillPattern) {
+            fillPattern = (dirtyFlag || !el.__canvasFillPattern)
+                ? createCanvasPattern(ctx, fill, el)
+                : el.__canvasFillPattern;
+            el.__canvasFillPattern = fillPattern;
+        }
+        if (hasStrokePattern) {
+            strokePattern = (dirtyFlag || !el.__canvasStrokePattern)
+                ? createCanvasPattern(ctx, stroke, el)
+                : el.__canvasStrokePattern;
+            el.__canvasStrokePattern = fillPattern;
+        }
+        if (hasFillGradient) {
+            ctx.fillStyle = fillGradient;
+        }
+        else if (hasFillPattern) {
+            if (fillPattern) {
+                ctx.fillStyle = fillPattern;
+            }
+            else {
+                hasFill = false;
+            }
+        }
+        if (hasStrokeGradient) {
+            ctx.strokeStyle = strokeGradient;
+        }
+        else if (hasStrokePattern) {
+            if (strokePattern) {
+                ctx.strokeStyle = strokePattern;
+            }
+            else {
+                hasStroke = false;
+            }
+        }
+    }
+    var scale = el.getGlobalScale();
+    path.setScale(scale[0], scale[1], el.segmentIgnoreThreshold);
+    var lineDash;
+    var lineDashOffset;
+    if (ctx.setLineDash && style.lineDash) {
+        _a = getLineDash(el), lineDash = _a[0], lineDashOffset = _a[1];
+    }
+    var needsRebuild = true;
+    if (firstDraw || (dirtyFlag & SHAPE_CHANGED_BIT)) {
+        path.setDPR(ctx.dpr);
+        if (strokePart) {
+            path.setContext(null);
+        }
+        else {
+            path.setContext(ctx);
+            needsRebuild = false;
+        }
+        path.reset();
+        el.buildPath(path, el.shape, inBatch);
+        path.toStatic();
+        el.pathUpdated();
+    }
+    if (needsRebuild) {
+        path.rebuildPath(ctx, strokePart ? strokePercent : 1);
+    }
+    if (lineDash) {
+        ctx.setLineDash(lineDash);
+        ctx.lineDashOffset = lineDashOffset;
+    }
+    if (!inBatch) {
+        if (style.strokeFirst) {
+            if (hasStroke) {
+                doStrokePath(ctx, style);
+            }
+            if (hasFill) {
+                doFillPath(ctx, style);
+            }
+        }
+        else {
+            if (hasFill) {
+                doFillPath(ctx, style);
+            }
+            if (hasStroke) {
+                doStrokePath(ctx, style);
+            }
+        }
+    }
+    if (lineDash) {
+        ctx.setLineDash([]);
+    }
+}
+function brushImage(ctx, el, style) {
+    var image = el.__image = createOrUpdateImage(style.image, el.__image, el, el.onload);
+    if (!image || !isImageReady(image)) {
+        return;
+    }
+    var x = style.x || 0;
+    var y = style.y || 0;
+    var width = el.getWidth();
+    var height = el.getHeight();
+    var aspect = image.width / image.height;
+    if (width == null && height != null) {
+        width = height * aspect;
+    }
+    else if (height == null && width != null) {
+        height = width / aspect;
+    }
+    else if (width == null && height == null) {
+        width = image.width;
+        height = image.height;
+    }
+    if (style.sWidth && style.sHeight) {
+        var sx = style.sx || 0;
+        var sy = style.sy || 0;
+        ctx.drawImage(image, sx, sy, style.sWidth, style.sHeight, x, y, width, height);
+    }
+    else if (style.sx && style.sy) {
+        var sx = style.sx;
+        var sy = style.sy;
+        var sWidth = width - sx;
+        var sHeight = height - sy;
+        ctx.drawImage(image, sx, sy, sWidth, sHeight, x, y, width, height);
+    }
+    else {
+        ctx.drawImage(image, x, y, width, height);
+    }
+}
+function brushText(ctx, el, style) {
+    var _a;
+    var text = style.text;
+    text != null && (text += '');
+    if (text) {
+        ctx.font = style.font || DEFAULT_FONT;
+        ctx.textAlign = style.textAlign;
+        ctx.textBaseline = style.textBaseline;
+        var lineDash = void 0;
+        var lineDashOffset = void 0;
+        if (ctx.setLineDash && style.lineDash) {
+            _a = getLineDash(el), lineDash = _a[0], lineDashOffset = _a[1];
+        }
+        if (lineDash) {
+            ctx.setLineDash(lineDash);
+            ctx.lineDashOffset = lineDashOffset;
+        }
+        if (style.strokeFirst) {
+            if (styleHasStroke(style)) {
+                ctx.strokeText(text, style.x, style.y);
+            }
+            if (styleHasFill(style)) {
+                ctx.fillText(text, style.x, style.y);
+            }
+        }
+        else {
+            if (styleHasFill(style)) {
+                ctx.fillText(text, style.x, style.y);
+            }
+            if (styleHasStroke(style)) {
+                ctx.strokeText(text, style.x, style.y);
+            }
+        }
+        if (lineDash) {
+            ctx.setLineDash([]);
+        }
+    }
+}
+var SHADOW_NUMBER_PROPS = ['shadowBlur', 'shadowOffsetX', 'shadowOffsetY'];
+var STROKE_PROPS = [
+    ['lineCap', 'butt'], ['lineJoin', 'miter'], ['miterLimit', 10]
+];
+function bindCommonProps(ctx, style, prevStyle, forceSetAll, scope) {
+    var styleChanged = false;
+    if (!forceSetAll) {
+        prevStyle = prevStyle || {};
+        if (style === prevStyle) {
+            return false;
+        }
+    }
+    if (forceSetAll || style.opacity !== prevStyle.opacity) {
+        flushPathDrawn(ctx, scope);
+        styleChanged = true;
+        var opacity = Math.max(Math.min(style.opacity, 1), 0);
+        ctx.globalAlpha = isNaN(opacity) ? DEFAULT_COMMON_STYLE.opacity : opacity;
+    }
+    if (forceSetAll || style.blend !== prevStyle.blend) {
+        if (!styleChanged) {
+            flushPathDrawn(ctx, scope);
+            styleChanged = true;
+        }
+        ctx.globalCompositeOperation = style.blend || DEFAULT_COMMON_STYLE.blend;
+    }
+    for (var i = 0; i < SHADOW_NUMBER_PROPS.length; i++) {
+        var propName = SHADOW_NUMBER_PROPS[i];
+        if (forceSetAll || style[propName] !== prevStyle[propName]) {
+            if (!styleChanged) {
+                flushPathDrawn(ctx, scope);
+                styleChanged = true;
+            }
+            ctx[propName] = ctx.dpr * (style[propName] || 0);
+        }
+    }
+    if (forceSetAll || style.shadowColor !== prevStyle.shadowColor) {
+        if (!styleChanged) {
+            flushPathDrawn(ctx, scope);
+            styleChanged = true;
+        }
+        ctx.shadowColor = style.shadowColor || DEFAULT_COMMON_STYLE.shadowColor;
+    }
+    return styleChanged;
+}
+function bindPathAndTextCommonStyle(ctx, el, prevEl, forceSetAll, scope) {
+    var style = getStyle(el, scope.inHover);
+    var prevStyle = forceSetAll
+        ? null
+        : (prevEl && getStyle(prevEl, scope.inHover) || {});
+    if (style === prevStyle) {
+        return false;
+    }
+    var styleChanged = bindCommonProps(ctx, style, prevStyle, forceSetAll, scope);
+    if (forceSetAll || style.fill !== prevStyle.fill) {
+        if (!styleChanged) {
+            flushPathDrawn(ctx, scope);
+            styleChanged = true;
+        }
+        isValidStrokeFillStyle(style.fill) && (ctx.fillStyle = style.fill);
+    }
+    if (forceSetAll || style.stroke !== prevStyle.stroke) {
+        if (!styleChanged) {
+            flushPathDrawn(ctx, scope);
+            styleChanged = true;
+        }
+        isValidStrokeFillStyle(style.stroke) && (ctx.strokeStyle = style.stroke);
+    }
+    if (forceSetAll || style.opacity !== prevStyle.opacity) {
+        if (!styleChanged) {
+            flushPathDrawn(ctx, scope);
+            styleChanged = true;
+        }
+        ctx.globalAlpha = style.opacity == null ? 1 : style.opacity;
+    }
+    if (el.hasStroke()) {
+        var lineWidth = style.lineWidth;
+        var newLineWidth = lineWidth / ((style.strokeNoScale && el.getLineScale) ? el.getLineScale() : 1);
+        if (ctx.lineWidth !== newLineWidth) {
+            if (!styleChanged) {
+                flushPathDrawn(ctx, scope);
+                styleChanged = true;
+            }
+            ctx.lineWidth = newLineWidth;
+        }
+    }
+    for (var i = 0; i < STROKE_PROPS.length; i++) {
+        var prop = STROKE_PROPS[i];
+        var propName = prop[0];
+        if (forceSetAll || style[propName] !== prevStyle[propName]) {
+            if (!styleChanged) {
+                flushPathDrawn(ctx, scope);
+                styleChanged = true;
+            }
+            ctx[propName] = style[propName] || prop[1];
+        }
+    }
+    return styleChanged;
+}
+function bindImageStyle(ctx, el, prevEl, forceSetAll, scope) {
+    return bindCommonProps(ctx, getStyle(el, scope.inHover), prevEl && getStyle(prevEl, scope.inHover), forceSetAll, scope);
+}
+function setContextTransform(ctx, el) {
+    var m = el.transform;
+    var dpr = ctx.dpr || 1;
+    if (m) {
+        ctx.setTransform(dpr * m[0], dpr * m[1], dpr * m[2], dpr * m[3], dpr * m[4], dpr * m[5]);
+    }
+    else {
+        ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+    }
+}
+function updateClipStatus(clipPaths, ctx, scope) {
+    var allClipped = false;
+    for (var i = 0; i < clipPaths.length; i++) {
+        var clipPath = clipPaths[i];
+        allClipped = allClipped || clipPath.isZeroArea();
+        setContextTransform(ctx, clipPath);
+        ctx.beginPath();
+        clipPath.buildPath(ctx, clipPath.shape);
+        ctx.clip();
+    }
+    scope.allClipped = allClipped;
+}
+function isTransformChanged(m0, m1) {
+    if (m0 && m1) {
+        return m0[0] !== m1[0]
+            || m0[1] !== m1[1]
+            || m0[2] !== m1[2]
+            || m0[3] !== m1[3]
+            || m0[4] !== m1[4]
+            || m0[5] !== m1[5];
+    }
+    else if (!m0 && !m1) {
+        return false;
+    }
+    return true;
+}
+var DRAW_TYPE_PATH = 1;
+var DRAW_TYPE_IMAGE = 2;
+var DRAW_TYPE_TEXT = 3;
+var DRAW_TYPE_INCREMENTAL = 4;
+function canPathBatch(style) {
+    var hasFill = styleHasFill(style);
+    var hasStroke = styleHasStroke(style);
+    return !(style.lineDash
+        || !(+hasFill ^ +hasStroke)
+        || (hasFill && typeof style.fill !== 'string')
+        || (hasStroke && typeof style.stroke !== 'string')
+        || style.strokePercent < 1
+        || style.strokeOpacity < 1
+        || style.fillOpacity < 1);
+}
+function flushPathDrawn(ctx, scope) {
+    scope.batchFill && ctx.fill();
+    scope.batchStroke && ctx.stroke();
+    scope.batchFill = '';
+    scope.batchStroke = '';
+}
+function getStyle(el, inHover) {
+    return inHover ? (el.__hoverStyle || el.style) : el.style;
+}
+export function brushSingle(ctx, el) {
+    brush(ctx, el, { inHover: false, viewWidth: 0, viewHeight: 0 }, true);
+}
+export function brush(ctx, el, scope, isLast) {
+    var m = el.transform;
+    if (!el.shouldBePainted(scope.viewWidth, scope.viewHeight, false, false)) {
+        el.__dirty &= ~REDRAW_BIT;
+        el.__isRendered = false;
+        return;
+    }
+    var clipPaths = el.__clipPaths;
+    var prevElClipPaths = scope.prevElClipPaths;
+    var forceSetTransform = false;
+    var forceSetStyle = false;
+    if (!prevElClipPaths || isClipPathChanged(clipPaths, prevElClipPaths)) {
+        if (prevElClipPaths && prevElClipPaths.length) {
+            flushPathDrawn(ctx, scope);
+            ctx.restore();
+            forceSetStyle = forceSetTransform = true;
+            scope.prevElClipPaths = null;
+            scope.allClipped = false;
+            scope.prevEl = null;
+        }
+        if (clipPaths && clipPaths.length) {
+            flushPathDrawn(ctx, scope);
+            ctx.save();
+            updateClipStatus(clipPaths, ctx, scope);
+            forceSetTransform = true;
+        }
+        scope.prevElClipPaths = clipPaths;
+    }
+    if (scope.allClipped) {
+        el.__isRendered = false;
+        return;
+    }
+    el.beforeBrush && el.beforeBrush();
+    el.innerBeforeBrush();
+    var prevEl = scope.prevEl;
+    if (!prevEl) {
+        forceSetStyle = forceSetTransform = true;
+    }
+    var canBatchPath = el instanceof Path
+        && el.autoBatch
+        && canPathBatch(el.style);
+    if (forceSetTransform || isTransformChanged(m, prevEl.transform)) {
+        flushPathDrawn(ctx, scope);
+        setContextTransform(ctx, el);
+    }
+    else if (!canBatchPath) {
+        flushPathDrawn(ctx, scope);
+    }
+    var style = getStyle(el, scope.inHover);
+    if (el instanceof Path) {
+        if (scope.lastDrawType !== DRAW_TYPE_PATH) {
+            forceSetStyle = true;
+            scope.lastDrawType = DRAW_TYPE_PATH;
+        }
+        bindPathAndTextCommonStyle(ctx, el, prevEl, forceSetStyle, scope);
+        if (!canBatchPath || (!scope.batchFill && !scope.batchStroke)) {
+            ctx.beginPath();
+        }
+        brushPath(ctx, el, style, canBatchPath);
+        if (canBatchPath) {
+            scope.batchFill = style.fill || '';
+            scope.batchStroke = style.stroke || '';
+        }
+    }
+    else {
+        if (el instanceof TSpan) {
+            if (scope.lastDrawType !== DRAW_TYPE_TEXT) {
+                forceSetStyle = true;
+                scope.lastDrawType = DRAW_TYPE_TEXT;
+            }
+            bindPathAndTextCommonStyle(ctx, el, prevEl, forceSetStyle, scope);
+            brushText(ctx, el, style);
+        }
+        else if (el instanceof ZRImage) {
+            if (scope.lastDrawType !== DRAW_TYPE_IMAGE) {
+                forceSetStyle = true;
+                scope.lastDrawType = DRAW_TYPE_IMAGE;
+            }
+            bindImageStyle(ctx, el, prevEl, forceSetStyle, scope);
+            brushImage(ctx, el, style);
+        }
+        else if (el.getTemporalDisplayables) {
+            if (scope.lastDrawType !== DRAW_TYPE_INCREMENTAL) {
+                forceSetStyle = true;
+                scope.lastDrawType = DRAW_TYPE_INCREMENTAL;
+            }
+            brushIncremental(ctx, el, scope);
+        }
+    }
+    if (canBatchPath && isLast) {
+        flushPathDrawn(ctx, scope);
+    }
+    el.innerAfterBrush();
+    el.afterBrush && el.afterBrush();
+    scope.prevEl = el;
+    el.__dirty = 0;
+    el.__isRendered = true;
+}
+function brushIncremental(ctx, el, scope) {
+    var displayables = el.getDisplayables();
+    var temporalDisplayables = el.getTemporalDisplayables();
+    ctx.save();
+    var innerScope = {
+        prevElClipPaths: null,
+        prevEl: null,
+        allClipped: false,
+        viewWidth: scope.viewWidth,
+        viewHeight: scope.viewHeight,
+        inHover: scope.inHover
+    };
+    var i;
+    var len;
+    for (i = el.getCursor(), len = displayables.length; i < len; i++) {
+        var displayable = displayables[i];
+        displayable.beforeBrush && displayable.beforeBrush();
+        displayable.innerBeforeBrush();
+        brush(ctx, displayable, innerScope, i === len - 1);
+        displayable.innerAfterBrush();
+        displayable.afterBrush && displayable.afterBrush();
+        innerScope.prevEl = displayable;
+    }
+    for (var i_1 = 0, len_1 = temporalDisplayables.length; i_1 < len_1; i_1++) {
+        var displayable = temporalDisplayables[i_1];
+        displayable.beforeBrush && displayable.beforeBrush();
+        displayable.innerBeforeBrush();
+        brush(ctx, displayable, innerScope, i_1 === len_1 - 1);
+        displayable.innerAfterBrush();
+        displayable.afterBrush && displayable.afterBrush();
+        innerScope.prevEl = displayable;
+    }
+    el.clearTemporalDisplayables();
+    el.notClear = true;
+    ctx.restore();
+}

uni-demo/node_modules/zrender/lib/canvas/helper.d.ts

@@ -0,0 +1,13 @@
+import { LinearGradientObject } from '../graphic/LinearGradient';
+import { RadialGradientObject } from '../graphic/RadialGradient';
+import { GradientObject } from '../graphic/Gradient';
+import { RectLike } from '../core/BoundingRect';
+import Path from '../graphic/Path';
+export declare function createLinearGradient(this: void, ctx: CanvasRenderingContext2D, obj: LinearGradientObject, rect: RectLike): CanvasGradient;
+export declare function createRadialGradient(this: void, ctx: CanvasRenderingContext2D, obj: RadialGradientObject, rect: RectLike): CanvasGradient;
+export declare function getCanvasGradient(this: void, ctx: CanvasRenderingContext2D, obj: GradientObject, rect: RectLike): CanvasGradient;
+export declare function isClipPathChanged(clipPaths: Path[], prevClipPaths: Path[]): boolean;
+export declare function getSize(root: HTMLElement, whIdx: number, opts: {
+    width?: number | string;
+    height?: number | string;
+}): number;

uni-demo/node_modules/zrender/lib/canvas/helper.js

@@ -0,0 +1,79 @@
+function isSafeNum(num) {
+    return isFinite(num);
+}
+export function createLinearGradient(ctx, obj, rect) {
+    var x = obj.x == null ? 0 : obj.x;
+    var x2 = obj.x2 == null ? 1 : obj.x2;
+    var y = obj.y == null ? 0 : obj.y;
+    var y2 = obj.y2 == null ? 0 : obj.y2;
+    if (!obj.global) {
+        x = x * rect.width + rect.x;
+        x2 = x2 * rect.width + rect.x;
+        y = y * rect.height + rect.y;
+        y2 = y2 * rect.height + rect.y;
+    }
+    x = isSafeNum(x) ? x : 0;
+    x2 = isSafeNum(x2) ? x2 : 1;
+    y = isSafeNum(y) ? y : 0;
+    y2 = isSafeNum(y2) ? y2 : 0;
+    var canvasGradient = ctx.createLinearGradient(x, y, x2, y2);
+    return canvasGradient;
+}
+export function createRadialGradient(ctx, obj, rect) {
+    var width = rect.width;
+    var height = rect.height;
+    var min = Math.min(width, height);
+    var x = obj.x == null ? 0.5 : obj.x;
+    var y = obj.y == null ? 0.5 : obj.y;
+    var r = obj.r == null ? 0.5 : obj.r;
+    if (!obj.global) {
+        x = x * width + rect.x;
+        y = y * height + rect.y;
+        r = r * min;
+    }
+    x = isSafeNum(x) ? x : 0.5;
+    y = isSafeNum(y) ? y : 0.5;
+    r = r >= 0 && isSafeNum(r) ? r : 0.5;
+    var canvasGradient = ctx.createRadialGradient(x, y, 0, x, y, r);
+    return canvasGradient;
+}
+export function getCanvasGradient(ctx, obj, rect) {
+    var canvasGradient = obj.type === 'radial'
+        ? createRadialGradient(ctx, obj, rect)
+        : createLinearGradient(ctx, obj, rect);
+    var colorStops = obj.colorStops;
+    for (var i = 0; i < colorStops.length; i++) {
+        canvasGradient.addColorStop(colorStops[i].offset, colorStops[i].color);
+    }
+    return canvasGradient;
+}
+export function isClipPathChanged(clipPaths, prevClipPaths) {
+    if (clipPaths === prevClipPaths || (!clipPaths && !prevClipPaths)) {
+        return false;
+    }
+    if (!clipPaths || !prevClipPaths || (clipPaths.length !== prevClipPaths.length)) {
+        return true;
+    }
+    for (var i = 0; i < clipPaths.length; i++) {
+        if (clipPaths[i] !== prevClipPaths[i]) {
+            return true;
+        }
+    }
+    return false;
+}
+function parseInt10(val) {
+    return parseInt(val, 10);
+}
+export function getSize(root, whIdx, opts) {
+    var wh = ['width', 'height'][whIdx];
+    var cwh = ['clientWidth', 'clientHeight'][whIdx];
+    var plt = ['paddingLeft', 'paddingTop'][whIdx];
+    var prb = ['paddingRight', 'paddingBottom'][whIdx];
+    if (opts[wh] != null && opts[wh] !== 'auto') {
+        return parseFloat(opts[wh]);
+    }
+    var stl = document.defaultView.getComputedStyle(root);
+    return ((root[cwh] || parseInt10(stl[wh]) || parseInt10(root.style[wh]))
+        - (parseInt10(stl[plt]) || 0)
+        - (parseInt10(stl[prb]) || 0)) | 0;
+}

uni-demo/node_modules/zrender/lib/config.d.ts

@@ -0,0 +1,6 @@
+export declare const debugMode = 0;
+export declare const devicePixelRatio: number;
+export declare const DARK_MODE_THRESHOLD = 0.4;
+export declare const DARK_LABEL_COLOR = "#333";
+export declare const LIGHT_LABEL_COLOR = "#ccc";
+export declare const LIGHTER_LABEL_COLOR = "#eee";

uni-demo/node_modules/zrender/lib/config.js

@@ -0,0 +1,13 @@
+import env from './core/env.js';
+var dpr = 1;
+if (env.hasGlobalWindow) {
+    dpr = Math.max(window.devicePixelRatio
+        || (window.screen && window.screen.deviceXDPI / window.screen.logicalXDPI)
+        || 1, 1);
+}
+export var debugMode = 0;
+export var devicePixelRatio = dpr;
+export var DARK_MODE_THRESHOLD = 0.4;
+export var DARK_LABEL_COLOR = '#333';
+export var LIGHT_LABEL_COLOR = '#ccc';
+export var LIGHTER_LABEL_COLOR = '#eee';

uni-demo/node_modules/zrender/lib/contain/arc.d.ts

@@ -0,0 +1 @@
+export declare function containStroke(cx: number, cy: number, r: number, startAngle: number, endAngle: number, anticlockwise: boolean, lineWidth: number, x: number, y: number): boolean;

uni-demo/node_modules/zrender/lib/contain/arc.js

@@ -0,0 +1,35 @@
+import { normalizeRadian } from './util.js';
+var PI2 = Math.PI * 2;
+export function containStroke(cx, cy, r, startAngle, endAngle, anticlockwise, lineWidth, x, y) {
+    if (lineWidth === 0) {
+        return false;
+    }
+    var _l = lineWidth;
+    x -= cx;
+    y -= cy;
+    var d = Math.sqrt(x * x + y * y);
+    if ((d - _l > r) || (d + _l < r)) {
+        return false;
+    }
+    if (Math.abs(startAngle - endAngle) % PI2 < 1e-4) {
+        return true;
+    }
+    if (anticlockwise) {
+        var tmp = startAngle;
+        startAngle = normalizeRadian(endAngle);
+        endAngle = normalizeRadian(tmp);
+    }
+    else {
+        startAngle = normalizeRadian(startAngle);
+        endAngle = normalizeRadian(endAngle);
+    }
+    if (startAngle > endAngle) {
+        endAngle += PI2;
+    }
+    var angle = Math.atan2(y, x);
+    if (angle < 0) {
+        angle += PI2;
+    }
+    return (angle >= startAngle && angle <= endAngle)
+        || (angle + PI2 >= startAngle && angle + PI2 <= endAngle);
+}

uni-demo/node_modules/zrender/lib/contain/cubic.d.ts

@@ -0,0 +1 @@
+export declare function containStroke(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, lineWidth: number, x: number, y: number): boolean;

uni-demo/node_modules/zrender/lib/contain/cubic.js

@@ -0,0 +1,15 @@
+import * as curve from '../core/curve.js';
+export function containStroke(x0, y0, x1, y1, x2, y2, x3, y3, lineWidth, x, y) {
+    if (lineWidth === 0) {
+        return false;
+    }
+    var _l = lineWidth;
+    if ((y > y0 + _l && y > y1 + _l && y > y2 + _l && y > y3 + _l)
+        || (y < y0 - _l && y < y1 - _l && y < y2 - _l && y < y3 - _l)
+        || (x > x0 + _l && x > x1 + _l && x > x2 + _l && x > x3 + _l)
+        || (x < x0 - _l && x < x1 - _l && x < x2 - _l && x < x3 - _l)) {
+        return false;
+    }
+    var d = curve.cubicProjectPoint(x0, y0, x1, y1, x2, y2, x3, y3, x, y, null);
+    return d <= _l / 2;
+}

uni-demo/node_modules/zrender/lib/contain/line.d.ts

@@ -0,0 +1 @@
+export declare function containStroke(x0: number, y0: number, x1: number, y1: number, lineWidth: number, x: number, y: number): boolean;

uni-demo/node_modules/zrender/lib/contain/line.js

@@ -0,0 +1,24 @@
+export function containStroke(x0, y0, x1, y1, lineWidth, x, y) {
+    if (lineWidth === 0) {
+        return false;
+    }
+    var _l = lineWidth;
+    var _a = 0;
+    var _b = x0;
+    if ((y > y0 + _l && y > y1 + _l)
+        || (y < y0 - _l && y < y1 - _l)
+        || (x > x0 + _l && x > x1 + _l)
+        || (x < x0 - _l && x < x1 - _l)) {
+        return false;
+    }
+    if (x0 !== x1) {
+        _a = (y0 - y1) / (x0 - x1);
+        _b = (x0 * y1 - x1 * y0) / (x0 - x1);
+    }
+    else {
+        return Math.abs(x - x0) <= _l / 2;
+    }
+    var tmp = _a * x - y + _b;
+    var _s = tmp * tmp / (_a * _a + 1);
+    return _s <= _l / 2 * _l / 2;
+}

uni-demo/node_modules/zrender/lib/contain/path.d.ts

@@ -0,0 +1,3 @@
+import PathProxy from '../core/PathProxy';
+export declare function contain(pathProxy: PathProxy, x: number, y: number): boolean;
+export declare function containStroke(pathProxy: PathProxy, lineWidth: number, x: number, y: number): boolean;

uni-demo/node_modules/zrender/lib/contain/path.js

@@ -0,0 +1,307 @@
+import PathProxy from '../core/PathProxy.js';
+import * as line from './line.js';
+import * as cubic from './cubic.js';
+import * as quadratic from './quadratic.js';
+import * as arc from './arc.js';
+import * as curve from '../core/curve.js';
+import windingLine from './windingLine.js';
+var CMD = PathProxy.CMD;
+var PI2 = Math.PI * 2;
+var EPSILON = 1e-4;
+function isAroundEqual(a, b) {
+    return Math.abs(a - b) < EPSILON;
+}
+var roots = [-1, -1, -1];
+var extrema = [-1, -1];
+function swapExtrema() {
+    var tmp = extrema[0];
+    extrema[0] = extrema[1];
+    extrema[1] = tmp;
+}
+function windingCubic(x0, y0, x1, y1, x2, y2, x3, y3, x, y) {
+    if ((y > y0 && y > y1 && y > y2 && y > y3)
+        || (y < y0 && y < y1 && y < y2 && y < y3)) {
+        return 0;
+    }
+    var nRoots = curve.cubicRootAt(y0, y1, y2, y3, y, roots);
+    if (nRoots === 0) {
+        return 0;
+    }
+    else {
+        var w = 0;
+        var nExtrema = -1;
+        var y0_ = void 0;
+        var y1_ = void 0;
+        for (var i = 0; i < nRoots; i++) {
+            var t = roots[i];
+            var unit = (t === 0 || t === 1) ? 0.5 : 1;
+            var x_ = curve.cubicAt(x0, x1, x2, x3, t);
+            if (x_ < x) {
+                continue;
+            }
+            if (nExtrema < 0) {
+                nExtrema = curve.cubicExtrema(y0, y1, y2, y3, extrema);
+                if (extrema[1] < extrema[0] && nExtrema > 1) {
+                    swapExtrema();
+                }
+                y0_ = curve.cubicAt(y0, y1, y2, y3, extrema[0]);
+                if (nExtrema > 1) {
+                    y1_ = curve.cubicAt(y0, y1, y2, y3, extrema[1]);
+                }
+            }
+            if (nExtrema === 2) {
+                if (t < extrema[0]) {
+                    w += y0_ < y0 ? unit : -unit;
+                }
+                else if (t < extrema[1]) {
+                    w += y1_ < y0_ ? unit : -unit;
+                }
+                else {
+                    w += y3 < y1_ ? unit : -unit;
+                }
+            }
+            else {
+                if (t < extrema[0]) {
+                    w += y0_ < y0 ? unit : -unit;
+                }
+                else {
+                    w += y3 < y0_ ? unit : -unit;
+                }
+            }
+        }
+        return w;
+    }
+}
+function windingQuadratic(x0, y0, x1, y1, x2, y2, x, y) {
+    if ((y > y0 && y > y1 && y > y2)
+        || (y < y0 && y < y1 && y < y2)) {
+        return 0;
+    }
+    var nRoots = curve.quadraticRootAt(y0, y1, y2, y, roots);
+    if (nRoots === 0) {
+        return 0;
+    }
+    else {
+        var t = curve.quadraticExtremum(y0, y1, y2);
+        if (t >= 0 && t <= 1) {
+            var w = 0;
+            var y_ = curve.quadraticAt(y0, y1, y2, t);
+            for (var i = 0; i < nRoots; i++) {
+                var unit = (roots[i] === 0 || roots[i] === 1) ? 0.5 : 1;
+                var x_ = curve.quadraticAt(x0, x1, x2, roots[i]);
+                if (x_ < x) {
+                    continue;
+                }
+                if (roots[i] < t) {
+                    w += y_ < y0 ? unit : -unit;
+                }
+                else {
+                    w += y2 < y_ ? unit : -unit;
+                }
+            }
+            return w;
+        }
+        else {
+            var unit = (roots[0] === 0 || roots[0] === 1) ? 0.5 : 1;
+            var x_ = curve.quadraticAt(x0, x1, x2, roots[0]);
+            if (x_ < x) {
+                return 0;
+            }
+            return y2 < y0 ? unit : -unit;
+        }
+    }
+}
+function windingArc(cx, cy, r, startAngle, endAngle, anticlockwise, x, y) {
+    y -= cy;
+    if (y > r || y < -r) {
+        return 0;
+    }
+    var tmp = Math.sqrt(r * r - y * y);
+    roots[0] = -tmp;
+    roots[1] = tmp;
+    var dTheta = Math.abs(startAngle - endAngle);
+    if (dTheta < 1e-4) {
+        return 0;
+    }
+    if (dTheta >= PI2 - 1e-4) {
+        startAngle = 0;
+        endAngle = PI2;
+        var dir = anticlockwise ? 1 : -1;
+        if (x >= roots[0] + cx && x <= roots[1] + cx) {
+            return dir;
+        }
+        else {
+            return 0;
+        }
+    }
+    if (startAngle > endAngle) {
+        var tmp_1 = startAngle;
+        startAngle = endAngle;
+        endAngle = tmp_1;
+    }
+    if (startAngle < 0) {
+        startAngle += PI2;
+        endAngle += PI2;
+    }
+    var w = 0;
+    for (var i = 0; i < 2; i++) {
+        var x_ = roots[i];
+        if (x_ + cx > x) {
+            var angle = Math.atan2(y, x_);
+            var dir = anticlockwise ? 1 : -1;
+            if (angle < 0) {
+                angle = PI2 + angle;
+            }
+            if ((angle >= startAngle && angle <= endAngle)
+                || (angle + PI2 >= startAngle && angle + PI2 <= endAngle)) {
+                if (angle > Math.PI / 2 && angle < Math.PI * 1.5) {
+                    dir = -dir;
+                }
+                w += dir;
+            }
+        }
+    }
+    return w;
+}
+function containPath(path, lineWidth, isStroke, x, y) {
+    var data = path.data;
+    var len = path.len();
+    var w = 0;
+    var xi = 0;
+    var yi = 0;
+    var x0 = 0;
+    var y0 = 0;
+    var x1;
+    var y1;
+    for (var i = 0; i < len;) {
+        var cmd = data[i++];
+        var isFirst = i === 1;
+        if (cmd === CMD.M && i > 1) {
+            if (!isStroke) {
+                w += windingLine(xi, yi, x0, y0, x, y);
+            }
+        }
+        if (isFirst) {
+            xi = data[i];
+            yi = data[i + 1];
+            x0 = xi;
+            y0 = yi;
+        }
+        switch (cmd) {
+            case CMD.M:
+                x0 = data[i++];
+                y0 = data[i++];
+                xi = x0;
+                yi = y0;
+                break;
+            case CMD.L:
+                if (isStroke) {
+                    if (line.containStroke(xi, yi, data[i], data[i + 1], lineWidth, x, y)) {
+                        return true;
+                    }
+                }
+                else {
+                    w += windingLine(xi, yi, data[i], data[i + 1], x, y) || 0;
+                }
+                xi = data[i++];
+                yi = data[i++];
+                break;
+            case CMD.C:
+                if (isStroke) {
+                    if (cubic.containStroke(xi, yi, data[i++], data[i++], data[i++], data[i++], data[i], data[i + 1], lineWidth, x, y)) {
+                        return true;
+                    }
+                }
+                else {
+                    w += windingCubic(xi, yi, data[i++], data[i++], data[i++], data[i++], data[i], data[i + 1], x, y) || 0;
+                }
+                xi = data[i++];
+                yi = data[i++];
+                break;
+            case CMD.Q:
+                if (isStroke) {
+                    if (quadratic.containStroke(xi, yi, data[i++], data[i++], data[i], data[i + 1], lineWidth, x, y)) {
+                        return true;
+                    }
+                }
+                else {
+                    w += windingQuadratic(xi, yi, data[i++], data[i++], data[i], data[i + 1], x, y) || 0;
+                }
+                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 theta = data[i++];
+                var dTheta = data[i++];
+                i += 1;
+                var anticlockwise = !!(1 - data[i++]);
+                x1 = Math.cos(theta) * rx + cx;
+                y1 = Math.sin(theta) * ry + cy;
+                if (!isFirst) {
+                    w += windingLine(xi, yi, x1, y1, x, y);
+                }
+                else {
+                    x0 = x1;
+                    y0 = y1;
+                }
+                var _x = (x - cx) * ry / rx + cx;
+                if (isStroke) {
+                    if (arc.containStroke(cx, cy, ry, theta, theta + dTheta, anticlockwise, lineWidth, _x, y)) {
+                        return true;
+                    }
+                }
+                else {
+                    w += windingArc(cx, cy, ry, theta, theta + dTheta, anticlockwise, _x, y);
+                }
+                xi = Math.cos(theta + dTheta) * rx + cx;
+                yi = Math.sin(theta + dTheta) * ry + cy;
+                break;
+            case CMD.R:
+                x0 = xi = data[i++];
+                y0 = yi = data[i++];
+                var width = data[i++];
+                var height = data[i++];
+                x1 = x0 + width;
+                y1 = y0 + height;
+                if (isStroke) {
+                    if (line.containStroke(x0, y0, x1, y0, lineWidth, x, y)
+                        || line.containStroke(x1, y0, x1, y1, lineWidth, x, y)
+                        || line.containStroke(x1, y1, x0, y1, lineWidth, x, y)
+                        || line.containStroke(x0, y1, x0, y0, lineWidth, x, y)) {
+                        return true;
+                    }
+                }
+                else {
+                    w += windingLine(x1, y0, x1, y1, x, y);
+                    w += windingLine(x0, y1, x0, y0, x, y);
+                }
+                break;
+            case CMD.Z:
+                if (isStroke) {
+                    if (line.containStroke(xi, yi, x0, y0, lineWidth, x, y)) {
+                        return true;
+                    }
+                }
+                else {
+                    w += windingLine(xi, yi, x0, y0, x, y);
+                }
+                xi = x0;
+                yi = y0;
+                break;
+        }
+    }
+    if (!isStroke && !isAroundEqual(yi, y0)) {
+        w += windingLine(xi, yi, x0, y0, x, y) || 0;
+    }
+    return w !== 0;
+}
+export function contain(pathProxy, x, y) {
+    return containPath(pathProxy, 0, false, x, y);
+}
+export function containStroke(pathProxy, lineWidth, x, y) {
+    return containPath(pathProxy, lineWidth, true, x, y);
+}

uni-demo/node_modules/zrender/lib/contain/polygon.d.ts

@@ -0,0 +1,2 @@
+import { VectorArray } from '../core/vector';
+export declare function contain(points: VectorArray[], x: number, y: number): boolean;

uni-demo/node_modules/zrender/lib/contain/polygon.js

@@ -0,0 +1,22 @@
+import windingLine from './windingLine.js';
+var EPSILON = 1e-8;
+function isAroundEqual(a, b) {
+    return Math.abs(a - b) < EPSILON;
+}
+export function contain(points, x, y) {
+    var w = 0;
+    var p = points[0];
+    if (!p) {
+        return false;
+    }
+    for (var i = 1; i < points.length; i++) {
+        var p2 = points[i];
+        w += windingLine(p[0], p[1], p2[0], p2[1], x, y);
+        p = p2;
+    }
+    var p0 = points[0];
+    if (!isAroundEqual(p[0], p0[0]) || !isAroundEqual(p[1], p0[1])) {
+        w += windingLine(p[0], p[1], p0[0], p0[1], x, y);
+    }
+    return w !== 0;
+}

uni-demo/node_modules/zrender/lib/contain/quadratic.d.ts

@@ -0,0 +1 @@
+export declare function containStroke(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, lineWidth: number, x: number, y: number): boolean;

uni-demo/node_modules/zrender/lib/contain/quadratic.js

@@ -0,0 +1,15 @@
+import { quadraticProjectPoint } from '../core/curve.js';
+export function containStroke(x0, y0, x1, y1, x2, y2, lineWidth, x, y) {
+    if (lineWidth === 0) {
+        return false;
+    }
+    var _l = lineWidth;
+    if ((y > y0 + _l && y > y1 + _l && y > y2 + _l)
+        || (y < y0 - _l && y < y1 - _l && y < y2 - _l)
+        || (x > x0 + _l && x > x1 + _l && x > x2 + _l)
+        || (x < x0 - _l && x < x1 - _l && x < x2 - _l)) {
+        return false;
+    }
+    var d = quadraticProjectPoint(x0, y0, x1, y1, x2, y2, x, y, null);
+    return d <= _l / 2;
+}

uni-demo/node_modules/zrender/lib/contain/text.d.ts

@@ -0,0 +1,23 @@
+import BoundingRect, { RectLike } from '../core/BoundingRect';
+import { TextAlign, TextVerticalAlign, BuiltinTextPosition } from '../core/types';
+export declare function getWidth(text: string, font: string): number;
+export declare function innerGetBoundingRect(text: string, font: string, textAlign?: TextAlign, textBaseline?: TextVerticalAlign): BoundingRect;
+export declare function getBoundingRect(text: string, font: string, textAlign?: TextAlign, textBaseline?: TextVerticalAlign): BoundingRect;
+export declare function adjustTextX(x: number, width: number, textAlign: TextAlign): number;
+export declare function adjustTextY(y: number, height: number, verticalAlign: TextVerticalAlign): number;
+export declare function getLineHeight(font?: string): number;
+export declare function measureText(text: string, font?: string): {
+    width: number;
+};
+export declare function parsePercent(value: number | string, maxValue: number): number;
+export interface TextPositionCalculationResult {
+    x: number;
+    y: number;
+    align: TextAlign;
+    verticalAlign: TextVerticalAlign;
+}
+export declare function calculateTextPosition(out: TextPositionCalculationResult, opts: {
+    position?: BuiltinTextPosition | (number | string)[];
+    distance?: number;
+    global?: boolean;
+}, rect: RectLike): TextPositionCalculationResult;

uni-demo/node_modules/zrender/lib/contain/text.js

@@ -0,0 +1,170 @@
+import BoundingRect from '../core/BoundingRect.js';
+import LRU from '../core/LRU.js';
+import { DEFAULT_FONT, platformApi } from '../core/platform.js';
+var textWidthCache = {};
+export function getWidth(text, font) {
+    font = font || DEFAULT_FONT;
+    var cacheOfFont = textWidthCache[font];
+    if (!cacheOfFont) {
+        cacheOfFont = textWidthCache[font] = new LRU(500);
+    }
+    var width = cacheOfFont.get(text);
+    if (width == null) {
+        width = platformApi.measureText(text, font).width;
+        cacheOfFont.put(text, width);
+    }
+    return width;
+}
+export function innerGetBoundingRect(text, font, textAlign, textBaseline) {
+    var width = getWidth(text, font);
+    var height = getLineHeight(font);
+    var x = adjustTextX(0, width, textAlign);
+    var y = adjustTextY(0, height, textBaseline);
+    var rect = new BoundingRect(x, y, width, height);
+    return rect;
+}
+export function getBoundingRect(text, font, textAlign, textBaseline) {
+    var textLines = ((text || '') + '').split('\n');
+    var len = textLines.length;
+    if (len === 1) {
+        return innerGetBoundingRect(textLines[0], font, textAlign, textBaseline);
+    }
+    else {
+        var uniondRect = new BoundingRect(0, 0, 0, 0);
+        for (var i = 0; i < textLines.length; i++) {
+            var rect = innerGetBoundingRect(textLines[i], font, textAlign, textBaseline);
+            i === 0 ? uniondRect.copy(rect) : uniondRect.union(rect);
+        }
+        return uniondRect;
+    }
+}
+export function adjustTextX(x, width, textAlign) {
+    if (textAlign === 'right') {
+        x -= width;
+    }
+    else if (textAlign === 'center') {
+        x -= width / 2;
+    }
+    return x;
+}
+export function adjustTextY(y, height, verticalAlign) {
+    if (verticalAlign === 'middle') {
+        y -= height / 2;
+    }
+    else if (verticalAlign === 'bottom') {
+        y -= height;
+    }
+    return y;
+}
+export function getLineHeight(font) {
+    return getWidth('国', font);
+}
+export function measureText(text, font) {
+    return platformApi.measureText(text, font);
+}
+export function parsePercent(value, maxValue) {
+    if (typeof value === 'string') {
+        if (value.lastIndexOf('%') >= 0) {
+            return parseFloat(value) / 100 * maxValue;
+        }
+        return parseFloat(value);
+    }
+    return value;
+}
+export function calculateTextPosition(out, opts, rect) {
+    var textPosition = opts.position || 'inside';
+    var distance = opts.distance != null ? opts.distance : 5;
+    var height = rect.height;
+    var width = rect.width;
+    var halfHeight = height / 2;
+    var x = rect.x;
+    var y = rect.y;
+    var textAlign = 'left';
+    var textVerticalAlign = 'top';
+    if (textPosition instanceof Array) {
+        x += parsePercent(textPosition[0], rect.width);
+        y += parsePercent(textPosition[1], rect.height);
+        textAlign = null;
+        textVerticalAlign = null;
+    }
+    else {
+        switch (textPosition) {
+            case 'left':
+                x -= distance;
+                y += halfHeight;
+                textAlign = 'right';
+                textVerticalAlign = 'middle';
+                break;
+            case 'right':
+                x += distance + width;
+                y += halfHeight;
+                textVerticalAlign = 'middle';
+                break;
+            case 'top':
+                x += width / 2;
+                y -= distance;
+                textAlign = 'center';
+                textVerticalAlign = 'bottom';
+                break;
+            case 'bottom':
+                x += width / 2;
+                y += height + distance;
+                textAlign = 'center';
+                break;
+            case 'inside':
+                x += width / 2;
+                y += halfHeight;
+                textAlign = 'center';
+                textVerticalAlign = 'middle';
+                break;
+            case 'insideLeft':
+                x += distance;
+                y += halfHeight;
+                textVerticalAlign = 'middle';
+                break;
+            case 'insideRight':
+                x += width - distance;
+                y += halfHeight;
+                textAlign = 'right';
+                textVerticalAlign = 'middle';
+                break;
+            case 'insideTop':
+                x += width / 2;
+                y += distance;
+                textAlign = 'center';
+                break;
+            case 'insideBottom':
+                x += width / 2;
+                y += height - distance;
+                textAlign = 'center';
+                textVerticalAlign = 'bottom';
+                break;
+            case 'insideTopLeft':
+                x += distance;
+                y += distance;
+                break;
+            case 'insideTopRight':
+                x += width - distance;
+                y += distance;
+                textAlign = 'right';
+                break;
+            case 'insideBottomLeft':
+                x += distance;
+                y += height - distance;
+                textVerticalAlign = 'bottom';
+                break;
+            case 'insideBottomRight':
+                x += width - distance;
+                y += height - distance;
+                textAlign = 'right';
+                textVerticalAlign = 'bottom';
+                break;
+        }
+    }
+    out = out || {};
+    out.x = x;
+    out.y = y;
+    out.align = textAlign;
+    out.verticalAlign = textVerticalAlign;
+    return out;
+}

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

@@ -0,0 +1 @@
+export declare function normalizeRadian(angle: number): number;

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

@@ -0,0 +1,8 @@
+var PI2 = Math.PI * 2;
+export function normalizeRadian(angle) {
+    angle %= PI2;
+    if (angle < 0) {
+        angle += PI2;
+    }
+    return angle;
+}

uni-demo/node_modules/zrender/lib/contain/windingLine.d.ts

@@ -0,0 +1 @@
+export default function windingLine(x0: number, y0: number, x1: number, y1: number, x: number, y: number): number;

uni-demo/node_modules/zrender/lib/contain/windingLine.js

@@ -0,0 +1,15 @@
+export default function windingLine(x0, y0, x1, y1, x, y) {
+    if ((y > y0 && y > y1) || (y < y0 && y < y1)) {
+        return 0;
+    }
+    if (y1 === y0) {
+        return 0;
+    }
+    var t = (y - y0) / (y1 - y0);
+    var dir = y1 < y0 ? 1 : -1;
+    if (t === 1 || t === 0) {
+        dir = y1 < y0 ? 0.5 : -0.5;
+    }
+    var x_ = t * (x1 - x0) + x0;
+    return x_ === x ? Infinity : x_ > x ? dir : 0;
+}

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;
+}

uni-demo/node_modules/zrender/lib/debug/showDebugDirtyRect.d.ts

@@ -0,0 +1,10 @@
+import type { ZRenderType } from '../zrender';
+interface Opts {
+    style?: {
+        backgroundColor?: string;
+        color?: string;
+    };
+    autoHideDelay?: number;
+}
+export default function showDebugDirtyRect(zr: ZRenderType, opts?: Opts): void;
+export {};

uni-demo/node_modules/zrender/lib/debug/showDebugDirtyRect.js

@@ -0,0 +1,83 @@
+import { extend } from '../core/util.js';
+var DebugRect = (function () {
+    function DebugRect(style) {
+        var dom = this.dom = document.createElement('div');
+        dom.className = 'ec-debug-dirty-rect';
+        style = extend({}, style);
+        extend(style, {
+            backgroundColor: 'rgba(0, 0, 255, 0.2)',
+            border: '1px solid #00f'
+        });
+        dom.style.cssText = "\nposition: absolute;\nopacity: 0;\ntransition: opacity 0.5s linear;\npointer-events: none;\n";
+        for (var key in style) {
+            if (style.hasOwnProperty(key)) {
+                dom.style[key] = style[key];
+            }
+        }
+    }
+    DebugRect.prototype.update = function (rect) {
+        var domStyle = this.dom.style;
+        domStyle.width = rect.width + 'px';
+        domStyle.height = rect.height + 'px';
+        domStyle.left = rect.x + 'px';
+        domStyle.top = rect.y + 'px';
+    };
+    DebugRect.prototype.hide = function () {
+        this.dom.style.opacity = '0';
+    };
+    DebugRect.prototype.show = function (autoHideDelay) {
+        var _this = this;
+        clearTimeout(this._hideTimeout);
+        this.dom.style.opacity = '1';
+        this._hideTimeout = setTimeout(function () {
+            _this.hide();
+        }, autoHideDelay || 1000);
+    };
+    return DebugRect;
+}());
+export default function showDebugDirtyRect(zr, opts) {
+    opts = opts || {};
+    var painter = zr.painter;
+    if (!painter.getLayers) {
+        throw new Error('Debug dirty rect can only been used on canvas renderer.');
+    }
+    if (painter.isSingleCanvas()) {
+        throw new Error('Debug dirty rect can only been used on zrender inited with container.');
+    }
+    var debugViewRoot = document.createElement('div');
+    debugViewRoot.style.cssText = "\nposition:absolute;\nleft:0;\ntop:0;\nright:0;\nbottom:0;\npointer-events:none;\n";
+    debugViewRoot.className = 'ec-debug-dirty-rect-container';
+    var debugRects = [];
+    var dom = zr.dom;
+    dom.appendChild(debugViewRoot);
+    var computedStyle = getComputedStyle(dom);
+    if (computedStyle.position === 'static') {
+        dom.style.position = 'relative';
+    }
+    zr.on('rendered', function () {
+        if (painter.getLayers) {
+            var idx_1 = 0;
+            painter.eachBuiltinLayer(function (layer) {
+                if (!layer.debugGetPaintRects) {
+                    return;
+                }
+                var paintRects = layer.debugGetPaintRects();
+                for (var i = 0; i < paintRects.length; i++) {
+                    if (!paintRects[i].width || !paintRects[i].height) {
+                        continue;
+                    }
+                    if (!debugRects[idx_1]) {
+                        debugRects[idx_1] = new DebugRect(opts.style);
+                        debugViewRoot.appendChild(debugRects[idx_1].dom);
+                    }
+                    debugRects[idx_1].show(opts.autoHideDelay);
+                    debugRects[idx_1].update(paintRects[i]);
+                    idx_1++;
+                }
+            });
+            for (var i = idx_1; i < debugRects.length; i++) {
+                debugRects[i].hide();
+            }
+        }
+    });
+}