{"version":3,"sources":["webpack://echarts-liquidfill/webpack/universalModuleDefinition","webpack://echarts-liquidfill/echarts-liquidfill.min.js","webpack://echarts-liquidfill/webpack/bootstrap","webpack://echarts-liquidfill/./node_modules/zrender/lib/core/util.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/graphic/Path.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/core/vector.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/core/BoundingRect.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/core/curve.js","webpack://echarts-liquidfill/external \"echarts\"","webpack://echarts-liquidfill/./node_modules/echarts/lib/config.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/graphic/Displayable.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/graphic/constant.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/core/PathProxy.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/core/matrix.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/graphic/helper/image.js","webpack://echarts-liquidfill/./node_modules/echarts/lib/util/model.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/core/env.js","webpack://echarts-liquidfill/./node_modules/echarts/lib/data/Source.js","webpack://echarts-liquidfill/./node_modules/echarts/lib/data/helper/sourceType.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/graphic/helper/fixShadow.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/Element.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/mixin/Transformable.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/tool/color.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/core/LRU.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/config.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/graphic/helper/text.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/contain/text.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/graphic/helper/roundRect.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/contain/util.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/graphic/helper/poly.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/graphic/helper/subPixelOptimize.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/graphic/Gradient.js","webpack://echarts-liquidfill/./index.js","webpack://echarts-liquidfill/./src/liquidFill.js","webpack://echarts-liquidfill/./src/liquidFillSeries.js","webpack://echarts-liquidfill/./node_modules/echarts/lib/data/helper/completeDimensions.js","webpack://echarts-liquidfill/./node_modules/echarts/lib/data/helper/sourceHelper.js","webpack://echarts-liquidfill/(webpack)/buildin/global.js","webpack://echarts-liquidfill/./node_modules/echarts/lib/model/referHelper.js","webpack://echarts-liquidfill/./node_modules/echarts/lib/util/clazz.js","webpack://echarts-liquidfill/./node_modules/echarts/lib/data/helper/dimensionHelper.js","webpack://echarts-liquidfill/./src/liquidFillView.js","webpack://echarts-liquidfill/./node_modules/echarts/lib/util/symbol.js","webpack://echarts-liquidfill/./node_modules/echarts/lib/util/graphic.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/tool/path.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/graphic/Style.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/core/guid.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/mixin/Eventful.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/mixin/Animatable.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/animation/Animator.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/animation/Clip.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/animation/easing.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/core/log.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/graphic/mixin/RectText.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/core/bbox.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/contain/path.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/contain/line.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/contain/cubic.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/contain/quadratic.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/contain/arc.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/contain/windingLine.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/graphic/Pattern.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/tool/transformPath.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/graphic/Image.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/container/Group.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/graphic/Text.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/graphic/shape/Circle.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/graphic/shape/Sector.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/graphic/helper/fixClipWithShadow.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/graphic/shape/Ring.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/graphic/shape/Polygon.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/graphic/helper/smoothSpline.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/graphic/helper/smoothBezier.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/graphic/shape/Polyline.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/graphic/shape/Rect.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/graphic/shape/Line.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/graphic/shape/BezierCurve.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/graphic/shape/Arc.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/graphic/CompoundPath.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/graphic/LinearGradient.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/graphic/RadialGradient.js","webpack://echarts-liquidfill/./node_modules/zrender/lib/graphic/IncrementalDisplayable.js","webpack://echarts-liquidfill/./src/liquidFillLayout.js","webpack://echarts-liquidfill/./node_modules/echarts/lib/visual/dataColor.js"],"names":["root","factory","exports","module","require","define","amd","echarts","window","__WEBPACK_EXTERNAL_MODULE__5__","modules","__webpack_require__","moduleId","installedModules","i","l","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","default","object","property","prototype","hasOwnProperty","p","s","clone","source","result","typeStr","objToString","isPrimitive","len","length","TYPED_ARRAY","Ctor","constructor","from","BUILTIN_OBJECT","isDom","merge","target","overwrite","isObject","targetProp","sourceProp","isArray","isBuiltInObject","defaults","overlay","each","obj","cb","context","forEach","nativeForEach","func","args","nativeSlice","arguments","apply","concat","type","nodeType","ownerDocument","primitiveKey","HashMap","visit","isArr","thisMap","set","this","data","[object Function]","[object RegExp]","[object Date]","[object Error]","[object CanvasGradient]","[object CanvasPattern]","[object Image]","[object Canvas]","[object Int8Array]","[object Uint8Array]","[object Uint8ClampedArray]","[object Int16Array]","[object Uint16Array]","[object Int32Array]","[object Uint32Array]","[object Float32Array]","[object Float64Array]","toString","arrayProto","Array","nativeFilter","filter","slice","nativeMap","map","nativeReduce","reduce","methods","createCanvas","document","createElement","_ctx","removeKey","$override","fn","mergeAll","targetAndSources","extend","getContext","indexOf","array","inherits","clazz","baseClazz","F","clazzPrototype","prop","superClass","mixin","isArrayLike","push","memo","find","curry","isFunction","isString","isTypedArray","eqNaN","retrieve","values","retrieve2","value0","value1","retrieve3","value2","Function","normalizeCssArray","val","assert","condition","message","Error","trim","str","replace","setAsPrimitive","createHashMap","concatArray","a","b","newArray","offset","noop","Path","opts","Displayable","path","zrUtil","PathProxy","pathContain","getCanvasPattern","abs","Math","pathProxyForDraw","__dirtyPath","strokeContainThreshold","subPixelOptimize","brush","ctx","prevEl","rect","style","hasStroke","hasFill","fill","stroke","hasFillGradient","colorStops","hasStrokeGradient","hasFillPattern","image","hasStrokePattern","setTransform","__dirty","getBoundingRect","_fillGradient","getGradient","_strokeGradient","fillStyle","strokeStyle","lineDash","lineDashOffset","ctxLineDash","setLineDash","scale","getGlobalScale","setScale","beginPath","setLineDashOffset","buildPath","shape","rebuildPath","fillOpacity","originalGlobalAlpha","globalAlpha","opacity","strokeOpacity","text","restoreTransform","drawRectText","shapeCfg","inBundle","createPathProxy","_rect","needsUpdateRect","rectWithStroke","_rectWithStroke","copy","w","lineWidth","lineScale","strokeNoScale","getLineScale","max","width","height","x","y","contain","localPos","transformCoordToLocal","pathData","containStroke","dirty","dirtyPath","__dirtyText","__zr","refresh","__clipTarget","animateShape","loop","animate","attrKV","setShape","transform","sqrt","Sub","extendFrom","defaultShape","thisShape","init","_default","v","lenSquare","distance","v1","v2","distanceSquare","ArrayCtor","Float32Array","lengthSquare","dist","distSquare","out","add","scaleAndAdd","sub","mul","div","dot","normalize","negate","lerp","applyTransform","min","BoundingRect","vec2","matrix","v2ApplyTransform","mathMin","mathMax","union","other","lt","rb","lb","rt","maxX","maxY","calculateTransform","sx","sy","translate","intersect","ax0","ax1","ay0","ay1","bx0","bx1","by0","by1","plain","isAroundZero","EPSILON","isNotAroundZero","cubicAt","p0","p1","p2","p3","onet","quadraticAt","_vector","v2Create","v2DistSquare","mathPow","pow","mathSqrt","EPSILON_NUMERIC","THREE_SQRT","ONE_THIRD","_v0","_v1","_v2","cubicDerivativeAt","cubicRootAt","roots","A","B","C","t1","disc","K","t2","discSqrt","Y1","Y2","T","theta","acos","ASqrt","tmp","cos","t3","sin","cubicExtrema","extrema","cubicSubdivide","p01","p12","p23","p012","p123","p0123","cubicProjectPoint","x0","y0","x1","y1","x2","y2","x3","y3","prev","next","d1","d2","interval","Infinity","_t","quadraticDerivativeAt","quadraticRootAt","quadraticExtremum","divider","quadraticSubdivide","quadraticProjectPoint","global","dev","__DEV__","Element","Style","__clipPaths","RectText","invisible","z","z2","zlevel","draggable","dragging","silent","culling","cursor","rectHover","progressive","incremental","globalScaleRatio","beforeBrush","afterBrush","rectContain","traverse","coord","animateStyle","setStyle","useStyle","ContextCachedBy","NONE","STYLE_BIND","PLAIN_TEXT","WILL_BE_RESTORED","curve","bbox","dpr","devicePixelRatio","CMD","M","L","Q","Z","R","min2","max2","mathCos","mathSin","mathAbs","hasTypedArray","notSaveData","_saveData","_xi","_yi","_x0","_y0","_ux","_uy","_len","_lineDash","_dashOffset","_dashIdx","_dashSum","moveTo","addData","lineTo","exceedUnit","_needsDash","_dashedLineTo","bezierCurveTo","_dashedBezierTo","quadraticCurveTo","_dashedQuadraticTo","arc","cx","cy","startAngle","endAngle","anticlockwise","arcTo","radius","h","closePath","toStatic","lineDashSum","setData","appendPath","appendSize","appendPathData","k","cmd","_expandData","_prevCmd","newData","dash","idx","dashSum","dx","dy","nDash","bezierLen","tmpLen","Number","MAX_VALUE","xi","yi","fromLine","fromCubic","fromQuadratic","rx","ry","fromArc","ux","uy","dTheta","psi","fs","scaleX","scaleY","rotate","identity","m1","m2","out0","out1","out2","out3","out4","out5","rad","aa","ac","atx","ab","ad","aty","st","ct","vx","vy","invert","det","imageOnLoad","cachedImgObj","__cachedImgObj","onload","onerror","pending","pendingWrap","cbPayload","hostEl","isImageReady","globalImageCache","findExistImage","newImageOrSrc","createOrUpdateImage","__zrImageSrc","Image","put","src","normalizeToArray","isIdInner","cptOption","id","has","env","DUMMY_COMPONENT_NAME_PREFIX","innerUniqueIndex","defaultEmphasis","opt","subOpts","emphasis","subOptName","TEXT_STYLE_OPTIONS","getDataItemValue","dataItem","Date","isDataItemOption","mappingToExists","exists","newCptOptions","index","exist","option","makeIdAndName","mapResult","idMap","item","existCpt","keyInfo","idNum","isNameSpecified","componentModel","compressBatches","batchA","batchB","makeMap","sourceBatch","otherMap","seriesId","dataIndices","dataIndex","otherDataIndices","j","lenj","mapToArray","isData","mapA","mapB","queryDataIndex","payload","dataIndexInside","indexOfRawIndex","indexOfName","makeInner","random","toFixed","hostObj","parseFinder","ecModel","finder","defaultMainType","parsedKey","match","mainType","queryType","toLowerCase","includeMainTypes","queryParam","models","queryComponents","setAttribute","dom","getAttribute","getTooltipRenderMode","renderModeOption","domSupported","groupData","getKey","buckets","keys","wx","getSystemInfoSync","browser","os","node","wxa","canvasSupported","svgSupported","touchEventsSupported","self","worker","navigator","ua","firefox","ie","edge","weChat","test","version","SVGRect","pointerEventsSupported","detect","userAgent","Source","fields","fromDataset","sourceFormat","SOURCE_FORMAT_KEYED_COLUMNS","SOURCE_FORMAT_UNKNOWN","seriesLayoutBy","SERIES_LAYOUT_BY_COLUMN","dimensionsDefine","encodeDefine","startIndex","dimensionsDetectCount","_util","enableClassCheck","_sourceType","SOURCE_FORMAT_ORIGINAL","SOURCE_FORMAT_TYPED_ARRAY","seriesDataToSource","SOURCE_FORMAT_ARRAY_ROWS","SOURCE_FORMAT_OBJECT_ROWS","SERIES_LAYOUT_BY_ROW","SHADOW_PROPS","shadowBlur","shadowOffsetX","shadowOffsetY","textShadowBlur","textShadowOffsetX","textShadowOffsetY","textBoxShadowBlur","textBoxShadowOffsetX","textBoxShadowOffsetY","propName","guid","Eventful","Transformable","Animatable","ignore","clipPath","isGroup","drift","decomposeTransform","beforeUpdate","afterUpdate","update","updateTransform","hide","show","attr","setClipPath","zr","addSelfToZr","removeClipPath","removeSelfFromZr","animators","animation","addAnimator","removeAnimator","vector","mIdentity","position","rotation","origin","transformableProto","needLocalTransform","scaleTmp","parent","parentHasTransform","getLocalTransform","relX","relY","invTransform","tmpTransform","originTransform","setLocalTransform","atan2","transformCoordToGlobal","clampCssByte","round","clampCssFloat","f","parseCssInt","charAt","parseFloat","parseInt","parseCssFloat","cssHueToRgb","lerpNumber","setRgba","g","copyRgba","putToCache","colorStr","rgbaArr","lastRemovedArr","colorCache","parse","cached","kCSSColorTable","op","ep","fname","substr","params","split","alpha","pop","hsla2rgba","iv","hsla","rgba","fastLerp","normalizedValue","colors","leftIndex","floor","rightIndex","ceil","leftColor","rightColor","dv","fullOutput","color","stringify","arrColor","transparent","aliceblue","antiquewhite","aqua","aquamarine","azure","beige","bisque","black","blanchedalmond","blue","blueviolet","brown","burlywood","cadetblue","chartreuse","chocolate","coral","cornflowerblue","cornsilk","crimson","cyan","darkblue","darkcyan","darkgoldenrod","darkgray","darkgreen","darkgrey","darkkhaki","darkmagenta","darkolivegreen","darkorange","darkorchid","darkred","darksalmon","darkseagreen","darkslateblue","darkslategray","darkslategrey","darkturquoise","darkviolet","deeppink","deepskyblue","dimgray","dimgrey","dodgerblue","firebrick","floralwhite","forestgreen","fuchsia","gainsboro","ghostwhite","gold","goldenrod","gray","green","greenyellow","grey","honeydew","hotpink","indianred","indigo","ivory","khaki","lavender","lavenderblush","lawngreen","lemonchiffon","lightblue","lightcoral","lightcyan","lightgoldenrodyellow","lightgray","lightgreen","lightgrey","lightpink","lightsalmon","lightseagreen","lightskyblue","lightslategray","lightslategrey","lightsteelblue","lightyellow","lime","limegreen","linen","magenta","maroon","mediumaquamarine","mediumblue","mediumorchid","mediumpurple","mediumseagreen","mediumslateblue","mediumspringgreen","mediumturquoise","mediumvioletred","midnightblue","mintcream","mistyrose","moccasin","navajowhite","navy","oldlace","olive","olivedrab","orange","orangered","orchid","palegoldenrod","palegreen","paleturquoise","palevioletred","papayawhip","peachpuff","peru","pink","plum","powderblue","purple","red","rosybrown","royalblue","saddlebrown","salmon","sandybrown","seagreen","seashell","sienna","silver","skyblue","slateblue","slategray","slategrey","snow","springgreen","steelblue","tan","teal","thistle","tomato","turquoise","violet","wheat","white","whitesmoke","yellow","yellowgreen","fastMapToColor","mapToColor","lift","level","colorArr","toHex","modifyHSL","H","S","G","vMin","vMax","delta","deltaR","deltaG","deltaB","rgba2hsla","clampCssAngle","modifyAlpha","LinkedList","head","tail","linkedListProto","insert","entry","Entry","insertEntry","remove","clear","LRU","maxSize","_list","_map","_maxSize","_lastRemovedEntry","LRUProto","list","removed","leastUsedEntry","debugMode","normalizeStyle","font","textContain","makeFont","textAlign","VALID_TEXT_ALIGN","textVerticalAlign","textBaseline","VALID_TEXT_VERTICAL_ALIGN","textPadding","applyTextRotation","textRotation","textOrigin","placeToken","token","lineHeight","lineTop","tokenStyle","rich","styleName","isLineHolder","needDrawBackground","drawBackground","getTextXForPadding","textHeight","setCtx","textShadowColor","DEFAULT_FONT","textStroke","getStroke","textStrokeWidth","textFill","getFill","strokeText","fillText","textBackgroundColor","textBorderWidth","textBorderColor","isPlainBg","textBoxShadowColor","textBorderRadius","roundRectHelper","imageHelper","onBgImageLoaded","drawImage","getBoxPosition","blockHeiht","baseX","baseY","textPosition","parsePercent","res","adjustTextPositionOnRect","textDistance","textOffset","fixShadow","maxValue","lastIndexOf","_constant","left","right","center","top","bottom","middle","SHADOW_STYLE_COMMON_PROPS","normalizeTextStyle","renderText","__attrCachedBy","contentBlock","__textCotentBlock","parseRichText","contentWidth","outerWidth","outerHeight","boxPos","boxX","adjustTextX","boxY","adjustTextY","xLeft","xRight","lines","line","tokens","tokenCount","usedWidth","lineXLeft","lineXRight","drawRichText","renderRichText","prevStyle","needDrawBg","checkCache","cachedByMe","styleFont","computedFont","__computedFont","__styleFont","textLineHeight","parsePlainText","truncate","textLines","textX","textY","textWidth","getWidth","propItem","styleProp","ctxProp","textStrokeWidthPrev","strokeWidthChanged","strokeChanged","renderPlainText","needDrawText","textWidthCache","measureText","textWidthCacheCounter","TEXT_CACHE_MAX","getPlainTextRect","getRichTextRect","truncateText","containerWidth","ellipsis","options","prepareTruncateOptions","truncateSingleLine","join","maxIterations","minChar","cnCharWidth","ascCharWidth","placeholder","ellipsisWidth","textLine","subLength","estimateLength","charCode","charCodeAt","getLineHeight","padding","truncOuterHeight","truncOuterWidth","lastIndex","STYLE_REG","exec","matchedIndex","pushTokens","substring","contentHeight","pendingList","stlPadding","truncateWidth","truncateHeight","tokenHeight","tokenWidth","tokenWidthNotSpecified","percentWidth","bgImg","paddingW","remianTruncWidth","block","isEmptyStr","strs","tokensLen","halfHeight","fontSize","fontFamily","fontStyle","fontWeight","textFont","r1","r2","r3","r4","total","PI","PI2","normalizeRadian","angle","smoothSpline","smoothBezier","points","smooth","controlPoints","smoothConstraint","cp1","cp2","positiveOrNegative","doubledPosition","subPixelOptimizeLine","outputShape","inputShape","subPixelOptimizeRect","originX","originY","originWidth","originHeight","Gradient","addColorStop","registerVisual","util","completeDimensions","extendSeriesModel","visualColorAccessPath","optionUpdated","gridSize","getInitialData","dimensions","List","initData","defaultOption","amplitude","waveLength","phase","period","direction","waveAnimation","animationEasing","animationEasingUpdate","animationDuration","animationDurationUpdate","outline","borderDistance","itemStyle","borderColor","borderWidth","shadowColor","backgroundStyle","label","insideColor","align","baseline","genName","fromZero","guessOrdinal","OTHER_DIMENSIONS","sysDims","applyDim","resultItem","coordDim","coordDimIndex","otherDims","coordDimNameMap","isInstance","dimsDef","encodeDef","dataDimNameMap","dimCount","optDimCount","sysDimItem","sysDimItemDimsDef","getDimCount","dimDefItem","userDimName","displayName","dataDims","validDataDims","resultDimIdx","availDimIdx","sysDimIndex","sysDimItemOtherDims","ordinalMeta","sysDimItemDimsDefItem","defaultTooltip","generateCoord","generateCoordCount","extra","isExtraCoord","completeBySourceData","sourceHeader","normalizeDimensionsDefine","findPotentialName","potentialNameDimIndex","arrayRowsTravelFirst","firstIndex","objectRowsCollectDimensions","colArr","dim","nameMap","count","maxLoop","makeDefaultEncode","seriesModel","datasetModel","completeResult","coordSysDefine","getCoordSysDefineBySeries","encode","encodeItemName","encodeSeriesName","seriesType","subType","nSeriesMap","cSeriesMap","datasetMap","inner","uid","datasetRecord","categoryWayDim","valueWayDim","coordSysDims","firstCategoryDimIndex","dataDim","categoryAxisMap","firstNotOrdinal","doGuessOrdinal","nameDimIndex","itemName","seriesName","dimIndex","detectValue","isFinite","dimName","sample","row","_model","detectSourceFormat","getSource","resetSourceDefaulter","prepareSource","seriesOption","getComponent","datasetIndex","getDatasetModel","datasetOption","eval","e","isCategory","axisModel","fetchers","cartesian2d","axisMap","xAxisModel","getReferringComponents","yAxisModel","singleAxis","singleAxisModel","polar","polarModel","radiusAxisModel","findAxisModel","angleAxisModel","geo","parallel","parallelModel","parallelAxisIndex","axisIndex","axisDim","coordSysName","fetch","parseClassType","componentType","ret","main","TYPE_DELIMITER","superCall","methodName","superApply","IS_CONTAINER","classBase","enableClassExtend","RootClass","mandatoryMethods","$constructor","proto","ExtendedClass","Clz","classAttr","enableClassManagement","entity","storage","registerClass","Clazz","checkClassType","container","makeContainer","getClass","componentMainType","throwWhenNotFound","getClassesByMainType","hasClass","getAllClassMainTypes","types","hasSubTypes","registerWhenExtend","originalExtend","setReadOnly","properties","summarizeDimensions","summary","notExtraCoordDimMap","defaultedLabel","defaultedTooltip","dimItem","getDimensionInfo","coordDimArr","dimType","mayLabelDimType","otherDim","otherDimArr","dataDimsOnCoord","encodeFirstDimNotExtra","dimArr","encodeLabel","encodeTooltip","tooltip","getDimensionTypeByAxis","axisType","numberUtil","number","symbolUtil","LiquidLayout","extendChartView","render","api","getPath","isForClipping","symbol","graphic","makePath","bouding","isFillContainer","createSymbol","Circle","getOutline","outlinePath","outterRadius","getModel","getItemStyle","getWave","isInverse","oldWave","radiusX","radiusY","itemModel","getItemModel","itemStyleModel","waterLevel","normalStyle","seriesColor","wave","inverse","_waterLevel","hoverStyle","setHoverStyle","clip","setWaveAnimation","maxSpeed","speed","cnt","defaultSpeed","phaseOffset","console","error","when","during","wavePath","start","group","removeAll","getData","getHeight","size","outlineDistance","outlineBorderWidth","showOutline","innerRadius","paddingRadius","strokePath","fillPath","Group","getBackground","oldData","_data","waves","diff","initProps","setItemGraphicEl","newIdx","oldIdx","waveElement","getItemGraphicEl","newWave","shapeAttrs","styleAttrs","updateProps","execute","labelModel","textOption","formatted","getFormattedLabel","defaultVal","defaultLabel","getName","isNaN","formatLabel","outsideTextRect","Rect","setText","insideTextRect","insColor","boundingCircle","CompoundPath","paths","getText","dispose","symbolPathSetColor","innerColor","symbolStyle","symbolShape","symbolType","__isEmptyBrush","Triangle","extendShape","Diamond","Pin","asin","tanX","tanY","cpLen","cpLen2","Arrow","symbolCtors","Line","roundRect","square","circle","diamond","pin","arrow","triangle","symbolShapeMakers","symbolBuildProxies","SymbolClz","proxySymbol","keepAspect","symbolPath","isEmpty","makeImage","setColor","layout","pathTool","createFromString","centerGraphic","resizePath","boundingRect","aspect","hasFillOrStroke","fillOrStroke","doSingleEnterHover","el","hoverStl","__hoverStl","__highlighted","useHoverLayer","elTarget","targetStyle","addHover","rollbackDefaultTextStyle","__hoverStlDirty","__cachedNormalStl","__cachedNormalZ2","elStyle","cacheElementStl","setDefaultHoverFillStroke","applyDefaultTextStyle","Z2_EMPHASIS_LIFT","liftedColor","liftedColorMap","colorTool","liftedColorCount","liftColor","doSingleLeaveHover","highlighted","removeHover","normalStl","normalZ2","traverseCall","method","child","setElementHoverStyle","onElementMouseOver","__hoverSilentOnTouch","zrByTouch","__isEmphasisEntered","onElementMouseOut","enterEmphasis","leaveEmphasis","setAsHoverStyleTrigger","disable","hoverSilentOnTouch","__hoverStyleTrigger","setTextStyle","textStyle","textStyleModel","specifiedTextStyle","isEmphasis","setTextStyleCommon","EMPTY_OBJ","isRectText","getShallow","labelRotate","richResult","globalTextStyle","richItemNames","richItemNameMap","parentModel","getRichItemNames","richTextStyle","setTokenTextStyle","forceRich","isBlock","getAutoColor","insideRawTextPosition","insideRollbackOpt","autoColor","textTag","disableBox","insideRollback","useInsideStyle","animateOrSetProps","isUpdate","props","animatableModel","isAnimationEnabled","postfix","duration","animationDelay","getAnimationDelayParams","animateTo","stopAnimation","ZImage","Text","Sector","Ring","Polygon","Polyline","BezierCurve","Arc","LinearGradient","RadialGradient","IncrementalDisplayable","mergePath","extendPath","extendFromString","imageUrl","img","param","isInEmphasis","setLabelStyle","emphasisStyle","normalModel","emphasisModel","normalSpecified","emphasisSpecified","baseText","labelFetcher","labelDataIndex","labelDimIndex","showNormal","showEmphasis","defaultText","normalStyleText","emphasisStyleText","defaultColor","getFont","gTextStyleModel","getTransform","ancestor","mat","transformDirection","hBase","vBase","vertex","groupTransition","g1","g2","getAnimatableProps","elMap1","elMap","anid","getElMap","oldEl","newProp","clipPointsByRect","point","clipRectByRect","targetRect","createIcon","iconStr","processArc","fa","psiDeg","xp","yp","lambda","cxp","cyp","vAngle","u","vRatio","createPathOptions","pathProxy","prevCmd","cpx","cpy","subpathX","subpathY","cmdList","commandReg","cmdText","cmdStr","numberReg","pLen","off","ctlPtx","ctlPty","createPathProxyFromString","transformPath","vMag","pathEls","pathList","pathEl","pathBundle","createLinearGradient","createRadialGradient","STYLE_COMMON_PROPS","styleProto","textRect","transformText","blend","notCheckCache","globalCompositeOperation","otherStyle","newStyle","canvasGradient","idStart","on","eventful","event","query","handler","isOnce","_h","_$handlers","host","eventProcessor","_$eventProcessor","normalizeQuery","wrap","one","callAtLast","zrEventfulCallAtLast","lastWrap","splice","arrySlice","isSilent","newList","trigger","argLen","hItem","afterTrigger","triggerWithContext","animatable","time","delay","easing","callback","forceAnimate","reverse","done","animateToShallow","objShallow","propertyCount","setAttrByPath","Animator","log","animatingShape","pathSplitted","animator","forwardToLast","stop","animateFrom","defaultGetter","defaultSetter","interpolateNumber","percent","interpolateString","interpolateArray","arrDim","len2","fillArr","arr0","arr1","arr0Len","arr1Len","arraySlice","isArraySame","catmullRomInterpolateArray","catmullRomInterpolate","v0","cloneValue","rgba2String","createTrackClip","oneTrackDone","keyframes","_getter","setter","_setter","useSpline","trackLen","trackMaxTime","firstVal","isValueArray","isValueColor","isValueString","lastValue","getArrayDim","sort","kfPercents","kfValues","prevValue","isAllValueEqual","colorArray","_target","lastFrame","lastFramePercent","Clip","life","_loop","_delay","onframe","frame","range","ondestroy","_tracks","_clipCount","_doneList","_onframeList","_clipList","tracks","pause","_paused","resume","isPaused","_doneCallback","doneList","lastClip","clipCount","addClip","oldOnFrame","clipList","removeClip","getClips","_life","_initialized","gap","onrestart","_pausedTime","easingFuncs","step","globalTime","deltaTime","_startTime","easingFunc","schedule","fire","restart","_needsRemove","remainder","eventType","arg","linear","quadraticIn","quadraticOut","quadraticInOut","cubicIn","cubicOut","cubicInOut","quarticIn","quarticOut","quarticInOut","quinticIn","quinticOut","quinticInOut","sinusoidalIn","sinusoidalOut","sinusoidalInOut","exponentialIn","exponentialOut","exponentialInOut","circularIn","circularOut","circularInOut","elasticIn","elasticOut","elasticInOut","backIn","backOut","backInOut","bounceIn","bounceOut","bounceInOut","textHelper","tmpRect","save","restore","end","extremity","xDim","yDim","fromPoints","tx","ty","vec2Min","vec2Max","isAroundEqual","swapExtrema","windingCubic","nRoots","y0_","y1_","nExtrema","unit","windingQuadratic","y_","windingArc","dir","x_","containPath","isStroke","windingLine","cubic","quadratic","_x","_a","_l","Pattern","repeat","createPattern","mathAtan2","nPoint","_image","sWidth","sHeight","_children","__storage","children","childAt","childOfName","childCount","_doAdd","addBefore","nextSibling","addToStorage","addChildrenToStorage","delFromStorage","delChildrenFromStorage","eachChild","includeChildren","tmpMat","childRect","fixClipWithShadow","r0","clockwise","unitX","unitY","shadowTemp","orignalBrush","modified","clipPaths","polyHelper","interpolate","v2Distance","isLoop","segs","pos","w2","w3","v2Min","v2Max","v2Scale","v2Add","v2Clone","v2Sub","constraint","prevPoint","nextPoint","cps","d0","sum","cp0","shift","subPixelOptimizeOutputShape","pointAt","someVectorAt","isTangent","cpx2","cpy2","cpx1","cpy1","_curve","tangentAt","_updatePathDirty","globalCoord","IncrementalDisplayble","Displayble","_displayables","_temporaryDisplayables","_cursor","notClear","clearDisplaybles","addDisplayable","displayable","notPersistent","addDisplayables","displayables","eachPendingDisplayable","getWaterPositions","stage","curves","waveRight","getTargetSeries","paletteScope","seiresModelMap","eachSeriesByType","__paletteScope","reset","dataAll","getRawData","idxMap","rawIdx","getRawIndex","filteredIdx","singleDataColor","getItemVisual","setItemVisual","getColorFromPalette"],"mappings":"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","file":"echarts-liquidfill.min.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory(require(\"echarts\"));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([\"echarts\"], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"echarts-liquidfill\"] = factory(require(\"echarts\"));\n\telse\n\t\troot[\"echarts-liquidfill\"] = factory(root[\"echarts\"]);\n})(window, function(__WEBPACK_EXTERNAL_MODULE__5__) {\nreturn ","(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory(require(\"echarts\"));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([\"echarts\"], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"echarts-liquidfill\"] = factory(require(\"echarts\"));\n\telse\n\t\troot[\"echarts-liquidfill\"] = factory(root[\"echarts\"]);\n})(window, function(__WEBPACK_EXTERNAL_MODULE__5__) {\nreturn /******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId]) {\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/ \t\t}\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\ti: moduleId,\n/******/ \t\t\tl: false,\n/******/ \t\t\texports: {}\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.l = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// define getter function for harmony exports\n/******/ \t__webpack_require__.d = function(exports, name, getter) {\n/******/ \t\tif(!__webpack_require__.o(exports, name)) {\n/******/ \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n/******/ \t\t}\n/******/ \t};\n/******/\n/******/ \t// define __esModule on exports\n/******/ \t__webpack_require__.r = function(exports) {\n/******/ \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n/******/ \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n/******/ \t\t}\n/******/ \t\tObject.defineProperty(exports, '__esModule', { value: true });\n/******/ \t};\n/******/\n/******/ \t// create a fake namespace object\n/******/ \t// mode & 1: value is a module id, require it\n/******/ \t// mode & 2: merge all properties of value into the ns\n/******/ \t// mode & 4: return value when already ns object\n/******/ \t// mode & 8|1: behave like require\n/******/ \t__webpack_require__.t = function(value, mode) {\n/******/ \t\tif(mode & 1) value = __webpack_require__(value);\n/******/ \t\tif(mode & 8) return value;\n/******/ \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n/******/ \t\tvar ns = Object.create(null);\n/******/ \t\t__webpack_require__.r(ns);\n/******/ \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n/******/ \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n/******/ \t\treturn ns;\n/******/ \t};\n/******/\n/******/ \t// getDefaultExport function for compatibility with non-harmony modules\n/******/ \t__webpack_require__.n = function(module) {\n/******/ \t\tvar getter = module && module.__esModule ?\n/******/ \t\t\tfunction getDefault() { return module['default']; } :\n/******/ \t\t\tfunction getModuleExports() { return module; };\n/******/ \t\t__webpack_require__.d(getter, 'a', getter);\n/******/ \t\treturn getter;\n/******/ \t};\n/******/\n/******/ \t// Object.prototype.hasOwnProperty.call\n/******/ \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(__webpack_require__.s = 29);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, exports) {\n\n/**\n * @module zrender/core/util\n */\n// 用于处理merge时无法遍历Date等对象的问题\nvar BUILTIN_OBJECT = {\n  '[object Function]': 1,\n  '[object RegExp]': 1,\n  '[object Date]': 1,\n  '[object Error]': 1,\n  '[object CanvasGradient]': 1,\n  '[object CanvasPattern]': 1,\n  // For node-canvas\n  '[object Image]': 1,\n  '[object Canvas]': 1\n};\nvar TYPED_ARRAY = {\n  '[object Int8Array]': 1,\n  '[object Uint8Array]': 1,\n  '[object Uint8ClampedArray]': 1,\n  '[object Int16Array]': 1,\n  '[object Uint16Array]': 1,\n  '[object Int32Array]': 1,\n  '[object Uint32Array]': 1,\n  '[object Float32Array]': 1,\n  '[object Float64Array]': 1\n};\nvar objToString = Object.prototype.toString;\nvar arrayProto = Array.prototype;\nvar nativeForEach = arrayProto.forEach;\nvar nativeFilter = arrayProto.filter;\nvar nativeSlice = arrayProto.slice;\nvar nativeMap = arrayProto.map;\nvar nativeReduce = arrayProto.reduce; // Avoid assign to an exported variable, for transforming to cjs.\n\nvar methods = {};\n\nfunction $override(name, fn) {\n  // Clear ctx instance for different environment\n  if (name === 'createCanvas') {\n    _ctx = null;\n  }\n\n  methods[name] = fn;\n}\n/**\n * Those data types can be cloned:\n *     Plain object, Array, TypedArray, number, string, null, undefined.\n * Those data types will be assgined using the orginal data:\n *     BUILTIN_OBJECT\n * Instance of user defined class will be cloned to a plain object, without\n * properties in prototype.\n * Other data types is not supported (not sure what will happen).\n *\n * Caution: do not support clone Date, for performance consideration.\n * (There might be a large number of date in `series.data`).\n * So date should not be modified in and out of echarts.\n *\n * @param {*} source\n * @return {*} new\n */\n\n\nfunction clone(source) {\n  if (source == null || typeof source !== 'object') {\n    return source;\n  }\n\n  var result = source;\n  var typeStr = objToString.call(source);\n\n  if (typeStr === '[object Array]') {\n    if (!isPrimitive(source)) {\n      result = [];\n\n      for (var i = 0, len = source.length; i < len; i++) {\n        result[i] = clone(source[i]);\n      }\n    }\n  } else if (TYPED_ARRAY[typeStr]) {\n    if (!isPrimitive(source)) {\n      var Ctor = source.constructor;\n\n      if (source.constructor.from) {\n        result = Ctor.from(source);\n      } else {\n        result = new Ctor(source.length);\n\n        for (var i = 0, len = source.length; i < len; i++) {\n          result[i] = clone(source[i]);\n        }\n      }\n    }\n  } else if (!BUILTIN_OBJECT[typeStr] && !isPrimitive(source) && !isDom(source)) {\n    result = {};\n\n    for (var key in source) {\n      if (source.hasOwnProperty(key)) {\n        result[key] = clone(source[key]);\n      }\n    }\n  }\n\n  return result;\n}\n/**\n * @memberOf module:zrender/core/util\n * @param {*} target\n * @param {*} source\n * @param {boolean} [overwrite=false]\n */\n\n\nfunction merge(target, source, overwrite) {\n  // We should escapse that source is string\n  // and enter for ... in ...\n  if (!isObject(source) || !isObject(target)) {\n    return overwrite ? clone(source) : target;\n  }\n\n  for (var key in source) {\n    if (source.hasOwnProperty(key)) {\n      var targetProp = target[key];\n      var sourceProp = source[key];\n\n      if (isObject(sourceProp) && isObject(targetProp) && !isArray(sourceProp) && !isArray(targetProp) && !isDom(sourceProp) && !isDom(targetProp) && !isBuiltInObject(sourceProp) && !isBuiltInObject(targetProp) && !isPrimitive(sourceProp) && !isPrimitive(targetProp)) {\n        // 如果需要递归覆盖，就递归调用merge\n        merge(targetProp, sourceProp, overwrite);\n      } else if (overwrite || !(key in target)) {\n        // 否则只处理overwrite为true，或者在目标对象中没有此属性的情况\n        // NOTE，在 target[key] 不存在的时候也是直接覆盖\n        target[key] = clone(source[key], true);\n      }\n    }\n  }\n\n  return target;\n}\n/**\n * @param {Array} targetAndSources The first item is target, and the rests are source.\n * @param {boolean} [overwrite=false]\n * @return {*} target\n */\n\n\nfunction mergeAll(targetAndSources, overwrite) {\n  var result = targetAndSources[0];\n\n  for (var i = 1, len = targetAndSources.length; i < len; i++) {\n    result = merge(result, targetAndSources[i], overwrite);\n  }\n\n  return result;\n}\n/**\n * @param {*} target\n * @param {*} source\n * @memberOf module:zrender/core/util\n */\n\n\nfunction extend(target, source) {\n  for (var key in source) {\n    if (source.hasOwnProperty(key)) {\n      target[key] = source[key];\n    }\n  }\n\n  return target;\n}\n/**\n * @param {*} target\n * @param {*} source\n * @param {boolean} [overlay=false]\n * @memberOf module:zrender/core/util\n */\n\n\nfunction defaults(target, source, overlay) {\n  for (var key in source) {\n    if (source.hasOwnProperty(key) && (overlay ? source[key] != null : target[key] == null)) {\n      target[key] = source[key];\n    }\n  }\n\n  return target;\n}\n\nvar createCanvas = function () {\n  return methods.createCanvas();\n};\n\nmethods.createCanvas = function () {\n  return document.createElement('canvas');\n}; // FIXME\n\n\nvar _ctx;\n\nfunction getContext() {\n  if (!_ctx) {\n    // Use util.createCanvas instead of createCanvas\n    // because createCanvas may be overwritten in different environment\n    _ctx = createCanvas().getContext('2d');\n  }\n\n  return _ctx;\n}\n/**\n * 查询数组中元素的index\n * @memberOf module:zrender/core/util\n */\n\n\nfunction indexOf(array, value) {\n  if (array) {\n    if (array.indexOf) {\n      return array.indexOf(value);\n    }\n\n    for (var i = 0, len = array.length; i < len; i++) {\n      if (array[i] === value) {\n        return i;\n      }\n    }\n  }\n\n  return -1;\n}\n/**\n * 构造类继承关系\n *\n * @memberOf module:zrender/core/util\n * @param {Function} clazz 源类\n * @param {Function} baseClazz 基类\n */\n\n\nfunction inherits(clazz, baseClazz) {\n  var clazzPrototype = clazz.prototype;\n\n  function F() {}\n\n  F.prototype = baseClazz.prototype;\n  clazz.prototype = new F();\n\n  for (var prop in clazzPrototype) {\n    clazz.prototype[prop] = clazzPrototype[prop];\n  }\n\n  clazz.prototype.constructor = clazz;\n  clazz.superClass = baseClazz;\n}\n/**\n * @memberOf module:zrender/core/util\n * @param {Object|Function} target\n * @param {Object|Function} sorce\n * @param {boolean} overlay\n */\n\n\nfunction mixin(target, source, overlay) {\n  target = 'prototype' in target ? target.prototype : target;\n  source = 'prototype' in source ? source.prototype : source;\n  defaults(target, source, overlay);\n}\n/**\n * Consider typed array.\n * @param {Array|TypedArray} data\n */\n\n\nfunction isArrayLike(data) {\n  if (!data) {\n    return;\n  }\n\n  if (typeof data === 'string') {\n    return false;\n  }\n\n  return typeof data.length === 'number';\n}\n/**\n * 数组或对象遍历\n * @memberOf module:zrender/core/util\n * @param {Object|Array} obj\n * @param {Function} cb\n * @param {*} [context]\n */\n\n\nfunction each(obj, cb, context) {\n  if (!(obj && cb)) {\n    return;\n  }\n\n  if (obj.forEach && obj.forEach === nativeForEach) {\n    obj.forEach(cb, context);\n  } else if (obj.length === +obj.length) {\n    for (var i = 0, len = obj.length; i < len; i++) {\n      cb.call(context, obj[i], i, obj);\n    }\n  } else {\n    for (var key in obj) {\n      if (obj.hasOwnProperty(key)) {\n        cb.call(context, obj[key], key, obj);\n      }\n    }\n  }\n}\n/**\n * 数组映射\n * @memberOf module:zrender/core/util\n * @param {Array} obj\n * @param {Function} cb\n * @param {*} [context]\n * @return {Array}\n */\n\n\nfunction map(obj, cb, context) {\n  if (!(obj && cb)) {\n    return;\n  }\n\n  if (obj.map && obj.map === nativeMap) {\n    return obj.map(cb, context);\n  } else {\n    var result = [];\n\n    for (var i = 0, len = obj.length; i < len; i++) {\n      result.push(cb.call(context, obj[i], i, obj));\n    }\n\n    return result;\n  }\n}\n/**\n * @memberOf module:zrender/core/util\n * @param {Array} obj\n * @param {Function} cb\n * @param {Object} [memo]\n * @param {*} [context]\n * @return {Array}\n */\n\n\nfunction reduce(obj, cb, memo, context) {\n  if (!(obj && cb)) {\n    return;\n  }\n\n  if (obj.reduce && obj.reduce === nativeReduce) {\n    return obj.reduce(cb, memo, context);\n  } else {\n    for (var i = 0, len = obj.length; i < len; i++) {\n      memo = cb.call(context, memo, obj[i], i, obj);\n    }\n\n    return memo;\n  }\n}\n/**\n * 数组过滤\n * @memberOf module:zrender/core/util\n * @param {Array} obj\n * @param {Function} cb\n * @param {*} [context]\n * @return {Array}\n */\n\n\nfunction filter(obj, cb, context) {\n  if (!(obj && cb)) {\n    return;\n  }\n\n  if (obj.filter && obj.filter === nativeFilter) {\n    return obj.filter(cb, context);\n  } else {\n    var result = [];\n\n    for (var i = 0, len = obj.length; i < len; i++) {\n      if (cb.call(context, obj[i], i, obj)) {\n        result.push(obj[i]);\n      }\n    }\n\n    return result;\n  }\n}\n/**\n * 数组项查找\n * @memberOf module:zrender/core/util\n * @param {Array} obj\n * @param {Function} cb\n * @param {*} [context]\n * @return {*}\n */\n\n\nfunction find(obj, cb, context) {\n  if (!(obj && cb)) {\n    return;\n  }\n\n  for (var i = 0, len = obj.length; i < len; i++) {\n    if (cb.call(context, obj[i], i, obj)) {\n      return obj[i];\n    }\n  }\n}\n/**\n * @memberOf module:zrender/core/util\n * @param {Function} func\n * @param {*} context\n * @return {Function}\n */\n\n\nfunction bind(func, context) {\n  var args = nativeSlice.call(arguments, 2);\n  return function () {\n    return func.apply(context, args.concat(nativeSlice.call(arguments)));\n  };\n}\n/**\n * @memberOf module:zrender/core/util\n * @param {Function} func\n * @return {Function}\n */\n\n\nfunction curry(func) {\n  var args = nativeSlice.call(arguments, 1);\n  return function () {\n    return func.apply(this, args.concat(nativeSlice.call(arguments)));\n  };\n}\n/**\n * @memberOf module:zrender/core/util\n * @param {*} value\n * @return {boolean}\n */\n\n\nfunction isArray(value) {\n  return objToString.call(value) === '[object Array]';\n}\n/**\n * @memberOf module:zrender/core/util\n * @param {*} value\n * @return {boolean}\n */\n\n\nfunction isFunction(value) {\n  return typeof value === 'function';\n}\n/**\n * @memberOf module:zrender/core/util\n * @param {*} value\n * @return {boolean}\n */\n\n\nfunction isString(value) {\n  return objToString.call(value) === '[object String]';\n}\n/**\n * @memberOf module:zrender/core/util\n * @param {*} value\n * @return {boolean}\n */\n\n\nfunction isObject(value) {\n  // Avoid a V8 JIT bug in Chrome 19-20.\n  // See https://code.google.com/p/v8/issues/detail?id=2291 for more details.\n  var type = typeof value;\n  return type === 'function' || !!value && type === 'object';\n}\n/**\n * @memberOf module:zrender/core/util\n * @param {*} value\n * @return {boolean}\n */\n\n\nfunction isBuiltInObject(value) {\n  return !!BUILTIN_OBJECT[objToString.call(value)];\n}\n/**\n * @memberOf module:zrender/core/util\n * @param {*} value\n * @return {boolean}\n */\n\n\nfunction isTypedArray(value) {\n  return !!TYPED_ARRAY[objToString.call(value)];\n}\n/**\n * @memberOf module:zrender/core/util\n * @param {*} value\n * @return {boolean}\n */\n\n\nfunction isDom(value) {\n  return typeof value === 'object' && typeof value.nodeType === 'number' && typeof value.ownerDocument === 'object';\n}\n/**\n * Whether is exactly NaN. Notice isNaN('a') returns true.\n * @param {*} value\n * @return {boolean}\n */\n\n\nfunction eqNaN(value) {\n  return value !== value;\n}\n/**\n * If value1 is not null, then return value1, otherwise judget rest of values.\n * Low performance.\n * @memberOf module:zrender/core/util\n * @return {*} Final value\n */\n\n\nfunction retrieve(values) {\n  for (var i = 0, len = arguments.length; i < len; i++) {\n    if (arguments[i] != null) {\n      return arguments[i];\n    }\n  }\n}\n\nfunction retrieve2(value0, value1) {\n  return value0 != null ? value0 : value1;\n}\n\nfunction retrieve3(value0, value1, value2) {\n  return value0 != null ? value0 : value1 != null ? value1 : value2;\n}\n/**\n * @memberOf module:zrender/core/util\n * @param {Array} arr\n * @param {number} startIndex\n * @param {number} endIndex\n * @return {Array}\n */\n\n\nfunction slice() {\n  return Function.call.apply(nativeSlice, arguments);\n}\n/**\n * Normalize css liked array configuration\n * e.g.\n *  3 => [3, 3, 3, 3]\n *  [4, 2] => [4, 2, 4, 2]\n *  [4, 3, 2] => [4, 3, 2, 3]\n * @param {number|Array.<number>} val\n * @return {Array.<number>}\n */\n\n\nfunction normalizeCssArray(val) {\n  if (typeof val === 'number') {\n    return [val, val, val, val];\n  }\n\n  var len = val.length;\n\n  if (len === 2) {\n    // vertical | horizontal\n    return [val[0], val[1], val[0], val[1]];\n  } else if (len === 3) {\n    // top | horizontal | bottom\n    return [val[0], val[1], val[2], val[1]];\n  }\n\n  return val;\n}\n/**\n * @memberOf module:zrender/core/util\n * @param {boolean} condition\n * @param {string} message\n */\n\n\nfunction assert(condition, message) {\n  if (!condition) {\n    throw new Error(message);\n  }\n}\n/**\n * @memberOf module:zrender/core/util\n * @param {string} str string to be trimed\n * @return {string} trimed string\n */\n\n\nfunction trim(str) {\n  if (str == null) {\n    return null;\n  } else if (typeof str.trim === 'function') {\n    return str.trim();\n  } else {\n    return str.replace(/^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g, '');\n  }\n}\n\nvar primitiveKey = '__ec_primitive__';\n/**\n * Set an object as primitive to be ignored traversing children in clone or merge\n */\n\nfunction setAsPrimitive(obj) {\n  obj[primitiveKey] = true;\n}\n\nfunction isPrimitive(obj) {\n  return obj[primitiveKey];\n}\n/**\n * @constructor\n * @param {Object} obj Only apply `ownProperty`.\n */\n\n\nfunction HashMap(obj) {\n  var isArr = isArray(obj); // Key should not be set on this, otherwise\n  // methods get/set/... may be overrided.\n\n  this.data = {};\n  var thisMap = this;\n  obj instanceof HashMap ? obj.each(visit) : obj && each(obj, visit);\n\n  function visit(value, key) {\n    isArr ? thisMap.set(value, key) : thisMap.set(key, value);\n  }\n}\n\nHashMap.prototype = {\n  constructor: HashMap,\n  // Do not provide `has` method to avoid defining what is `has`.\n  // (We usually treat `null` and `undefined` as the same, different\n  // from ES6 Map).\n  get: function (key) {\n    return this.data.hasOwnProperty(key) ? this.data[key] : null;\n  },\n  set: function (key, value) {\n    // Comparing with invocation chaining, `return value` is more commonly\n    // used in this case: `var someVal = map.set('a', genVal());`\n    return this.data[key] = value;\n  },\n  // Although util.each can be performed on this hashMap directly, user\n  // should not use the exposed keys, who are prefixed.\n  each: function (cb, context) {\n    context !== void 0 && (cb = bind(cb, context));\n\n    for (var key in this.data) {\n      this.data.hasOwnProperty(key) && cb(this.data[key], key);\n    }\n  },\n  // Do not use this method if performance sensitive.\n  removeKey: function (key) {\n    delete this.data[key];\n  }\n};\n\nfunction createHashMap(obj) {\n  return new HashMap(obj);\n}\n\nfunction concatArray(a, b) {\n  var newArray = new a.constructor(a.length + b.length);\n\n  for (var i = 0; i < a.length; i++) {\n    newArray[i] = a[i];\n  }\n\n  var offset = a.length;\n\n  for (i = 0; i < b.length; i++) {\n    newArray[i + offset] = b[i];\n  }\n\n  return newArray;\n}\n\nfunction noop() {}\n\nexports.$override = $override;\nexports.clone = clone;\nexports.merge = merge;\nexports.mergeAll = mergeAll;\nexports.extend = extend;\nexports.defaults = defaults;\nexports.createCanvas = createCanvas;\nexports.getContext = getContext;\nexports.indexOf = indexOf;\nexports.inherits = inherits;\nexports.mixin = mixin;\nexports.isArrayLike = isArrayLike;\nexports.each = each;\nexports.map = map;\nexports.reduce = reduce;\nexports.filter = filter;\nexports.find = find;\nexports.bind = bind;\nexports.curry = curry;\nexports.isArray = isArray;\nexports.isFunction = isFunction;\nexports.isString = isString;\nexports.isObject = isObject;\nexports.isBuiltInObject = isBuiltInObject;\nexports.isTypedArray = isTypedArray;\nexports.isDom = isDom;\nexports.eqNaN = eqNaN;\nexports.retrieve = retrieve;\nexports.retrieve2 = retrieve2;\nexports.retrieve3 = retrieve3;\nexports.slice = slice;\nexports.normalizeCssArray = normalizeCssArray;\nexports.assert = assert;\nexports.trim = trim;\nexports.setAsPrimitive = setAsPrimitive;\nexports.isPrimitive = isPrimitive;\nexports.createHashMap = createHashMap;\nexports.concatArray = concatArray;\nexports.noop = noop;\n\n/***/ }),\n/* 1 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar Displayable = __webpack_require__(7);\n\nvar zrUtil = __webpack_require__(0);\n\nvar PathProxy = __webpack_require__(9);\n\nvar pathContain = __webpack_require__(52);\n\nvar Pattern = __webpack_require__(58);\n\nvar getCanvasPattern = Pattern.prototype.getCanvasPattern;\nvar abs = Math.abs;\nvar pathProxyForDraw = new PathProxy(true);\n/**\n * @alias module:zrender/graphic/Path\n * @extends module:zrender/graphic/Displayable\n * @constructor\n * @param {Object} opts\n */\n\nfunction Path(opts) {\n  Displayable.call(this, opts);\n  /**\n   * @type {module:zrender/core/PathProxy}\n   * @readOnly\n   */\n\n  this.path = null;\n}\n\nPath.prototype = {\n  constructor: Path,\n  type: 'path',\n  __dirtyPath: true,\n  strokeContainThreshold: 5,\n\n  /**\n   * See `module:zrender/src/graphic/helper/subPixelOptimize`.\n   * @type {boolean}\n   */\n  subPixelOptimize: false,\n  brush: function (ctx, prevEl) {\n    var style = this.style;\n    var path = this.path || pathProxyForDraw;\n    var hasStroke = style.hasStroke();\n    var hasFill = style.hasFill();\n    var fill = style.fill;\n    var stroke = style.stroke;\n    var hasFillGradient = hasFill && !!fill.colorStops;\n    var hasStrokeGradient = hasStroke && !!stroke.colorStops;\n    var hasFillPattern = hasFill && !!fill.image;\n    var hasStrokePattern = hasStroke && !!stroke.image;\n    style.bind(ctx, this, prevEl);\n    this.setTransform(ctx);\n\n    if (this.__dirty) {\n      var rect; // Update gradient because bounding rect may changed\n\n      if (hasFillGradient) {\n        rect = rect || this.getBoundingRect();\n        this._fillGradient = style.getGradient(ctx, fill, rect);\n      }\n\n      if (hasStrokeGradient) {\n        rect = rect || this.getBoundingRect();\n        this._strokeGradient = style.getGradient(ctx, stroke, rect);\n      }\n    } // Use the gradient or pattern\n\n\n    if (hasFillGradient) {\n      // PENDING If may have affect the state\n      ctx.fillStyle = this._fillGradient;\n    } else if (hasFillPattern) {\n      ctx.fillStyle = getCanvasPattern.call(fill, ctx);\n    }\n\n    if (hasStrokeGradient) {\n      ctx.strokeStyle = this._strokeGradient;\n    } else if (hasStrokePattern) {\n      ctx.strokeStyle = getCanvasPattern.call(stroke, ctx);\n    }\n\n    var lineDash = style.lineDash;\n    var lineDashOffset = style.lineDashOffset;\n    var ctxLineDash = !!ctx.setLineDash; // Update path sx, sy\n\n    var scale = this.getGlobalScale();\n    path.setScale(scale[0], scale[1]); // Proxy context\n    // Rebuild path in following 2 cases\n    // 1. Path is dirty\n    // 2. Path needs javascript implemented lineDash stroking.\n    //    In this case, lineDash information will not be saved in PathProxy\n\n    if (this.__dirtyPath || lineDash && !ctxLineDash && hasStroke) {\n      path.beginPath(ctx); // Setting line dash before build path\n\n      if (lineDash && !ctxLineDash) {\n        path.setLineDash(lineDash);\n        path.setLineDashOffset(lineDashOffset);\n      }\n\n      this.buildPath(path, this.shape, false); // Clear path dirty flag\n\n      if (this.path) {\n        this.__dirtyPath = false;\n      }\n    } else {\n      // Replay path building\n      ctx.beginPath();\n      this.path.rebuildPath(ctx);\n    }\n\n    if (hasFill) {\n      if (style.fillOpacity != null) {\n        var originalGlobalAlpha = ctx.globalAlpha;\n        ctx.globalAlpha = style.fillOpacity * style.opacity;\n        path.fill(ctx);\n        ctx.globalAlpha = originalGlobalAlpha;\n      } else {\n        path.fill(ctx);\n      }\n    }\n\n    if (lineDash && ctxLineDash) {\n      ctx.setLineDash(lineDash);\n      ctx.lineDashOffset = lineDashOffset;\n    }\n\n    if (hasStroke) {\n      if (style.strokeOpacity != null) {\n        var originalGlobalAlpha = ctx.globalAlpha;\n        ctx.globalAlpha = style.strokeOpacity * style.opacity;\n        path.stroke(ctx);\n        ctx.globalAlpha = originalGlobalAlpha;\n      } else {\n        path.stroke(ctx);\n      }\n    }\n\n    if (lineDash && ctxLineDash) {\n      // PENDING\n      // Remove lineDash\n      ctx.setLineDash([]);\n    } // Draw rect text\n\n\n    if (style.text != null) {\n      // Only restore transform when needs draw text.\n      this.restoreTransform(ctx);\n      this.drawRectText(ctx, this.getBoundingRect());\n    }\n  },\n  // When bundling path, some shape may decide if use moveTo to begin a new subpath or closePath\n  // Like in circle\n  buildPath: function (ctx, shapeCfg, inBundle) {},\n  createPathProxy: function () {\n    this.path = new PathProxy();\n  },\n  getBoundingRect: function () {\n    var rect = this._rect;\n    var style = this.style;\n    var needsUpdateRect = !rect;\n\n    if (needsUpdateRect) {\n      var path = this.path;\n\n      if (!path) {\n        // Create path on demand.\n        path = this.path = new PathProxy();\n      }\n\n      if (this.__dirtyPath) {\n        path.beginPath();\n        this.buildPath(path, this.shape, false);\n      }\n\n      rect = path.getBoundingRect();\n    }\n\n    this._rect = rect;\n\n    if (style.hasStroke()) {\n      // Needs update rect with stroke lineWidth when\n      // 1. Element changes scale or lineWidth\n      // 2. Shape is changed\n      var rectWithStroke = this._rectWithStroke || (this._rectWithStroke = rect.clone());\n\n      if (this.__dirty || needsUpdateRect) {\n        rectWithStroke.copy(rect); // FIXME Must after updateTransform\n\n        var w = style.lineWidth; // PENDING, Min line width is needed when line is horizontal or vertical\n\n        var lineScale = style.strokeNoScale ? this.getLineScale() : 1; // Only add extra hover lineWidth when there are no fill\n\n        if (!style.hasFill()) {\n          w = Math.max(w, this.strokeContainThreshold || 4);\n        } // Consider line width\n        // Line scale can't be 0;\n\n\n        if (lineScale > 1e-10) {\n          rectWithStroke.width += w / lineScale;\n          rectWithStroke.height += w / lineScale;\n          rectWithStroke.x -= w / lineScale / 2;\n          rectWithStroke.y -= w / lineScale / 2;\n        }\n      } // Return rect with stroke\n\n\n      return rectWithStroke;\n    }\n\n    return rect;\n  },\n  contain: function (x, y) {\n    var localPos = this.transformCoordToLocal(x, y);\n    var rect = this.getBoundingRect();\n    var style = this.style;\n    x = localPos[0];\n    y = localPos[1];\n\n    if (rect.contain(x, y)) {\n      var pathData = this.path.data;\n\n      if (style.hasStroke()) {\n        var lineWidth = style.lineWidth;\n        var lineScale = style.strokeNoScale ? this.getLineScale() : 1; // Line scale can't be 0;\n\n        if (lineScale > 1e-10) {\n          // Only add extra hover lineWidth when there are no fill\n          if (!style.hasFill()) {\n            lineWidth = Math.max(lineWidth, this.strokeContainThreshold);\n          }\n\n          if (pathContain.containStroke(pathData, lineWidth / lineScale, x, y)) {\n            return true;\n          }\n        }\n      }\n\n      if (style.hasFill()) {\n        return pathContain.contain(pathData, x, y);\n      }\n    }\n\n    return false;\n  },\n\n  /**\n   * @param  {boolean} dirtyPath\n   */\n  dirty: function (dirtyPath) {\n    if (dirtyPath == null) {\n      dirtyPath = true;\n    } // Only mark dirty, not mark clean\n\n\n    if (dirtyPath) {\n      this.__dirtyPath = dirtyPath;\n      this._rect = null;\n    }\n\n    this.__dirty = this.__dirtyText = true;\n    this.__zr && this.__zr.refresh(); // Used as a clipping path\n\n    if (this.__clipTarget) {\n      this.__clipTarget.dirty();\n    }\n  },\n\n  /**\n   * Alias for animate('shape')\n   * @param {boolean} loop\n   */\n  animateShape: function (loop) {\n    return this.animate('shape', loop);\n  },\n  // Overwrite attrKV\n  attrKV: function (key, value) {\n    // FIXME\n    if (key === 'shape') {\n      this.setShape(value);\n      this.__dirtyPath = true;\n      this._rect = null;\n    } else {\n      Displayable.prototype.attrKV.call(this, key, value);\n    }\n  },\n\n  /**\n   * @param {Object|string} key\n   * @param {*} value\n   */\n  setShape: function (key, value) {\n    var shape = this.shape; // Path from string may not have shape\n\n    if (shape) {\n      if (zrUtil.isObject(key)) {\n        for (var name in key) {\n          if (key.hasOwnProperty(name)) {\n            shape[name] = key[name];\n          }\n        }\n      } else {\n        shape[key] = value;\n      }\n\n      this.dirty(true);\n    }\n\n    return this;\n  },\n  getLineScale: function () {\n    var m = this.transform; // Get the line scale.\n    // Determinant of `m` means how much the area is enlarged by the\n    // transformation. So its square root can be used as a scale factor\n    // for width.\n\n    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;\n  }\n};\n/**\n * 扩展一个 Path element, 比如星形，圆等。\n * Extend a path element\n * @param {Object} props\n * @param {string} props.type Path type\n * @param {Function} props.init Initialize\n * @param {Function} props.buildPath Overwrite buildPath method\n * @param {Object} [props.style] Extended default style config\n * @param {Object} [props.shape] Extended default shape config\n */\n\nPath.extend = function (defaults) {\n  var Sub = function (opts) {\n    Path.call(this, opts);\n\n    if (defaults.style) {\n      // Extend default style\n      this.style.extendFrom(defaults.style, false);\n    } // Extend default shape\n\n\n    var defaultShape = defaults.shape;\n\n    if (defaultShape) {\n      this.shape = this.shape || {};\n      var thisShape = this.shape;\n\n      for (var name in defaultShape) {\n        if (!thisShape.hasOwnProperty(name) && defaultShape.hasOwnProperty(name)) {\n          thisShape[name] = defaultShape[name];\n        }\n      }\n    }\n\n    defaults.init && defaults.init.call(this, opts);\n  };\n\n  zrUtil.inherits(Sub, Path); // FIXME 不能 extend position, rotation 等引用对象\n\n  for (var name in defaults) {\n    // Extending prototype values and methods\n    if (name !== 'style' && name !== 'shape') {\n      Sub.prototype[name] = defaults[name];\n    }\n  }\n\n  return Sub;\n};\n\nzrUtil.inherits(Path, Displayable);\nvar _default = Path;\nmodule.exports = _default;\n\n/***/ }),\n/* 2 */\n/***/ (function(module, exports) {\n\nvar ArrayCtor = typeof Float32Array === 'undefined' ? Array : Float32Array;\n/**\n * 创建一个向量\n * @param {number} [x=0]\n * @param {number} [y=0]\n * @return {Vector2}\n */\n\nfunction create(x, y) {\n  var out = new ArrayCtor(2);\n\n  if (x == null) {\n    x = 0;\n  }\n\n  if (y == null) {\n    y = 0;\n  }\n\n  out[0] = x;\n  out[1] = y;\n  return out;\n}\n/**\n * 复制向量数据\n * @param {Vector2} out\n * @param {Vector2} v\n * @return {Vector2}\n */\n\n\nfunction copy(out, v) {\n  out[0] = v[0];\n  out[1] = v[1];\n  return out;\n}\n/**\n * 克隆一个向量\n * @param {Vector2} v\n * @return {Vector2}\n */\n\n\nfunction clone(v) {\n  var out = new ArrayCtor(2);\n  out[0] = v[0];\n  out[1] = v[1];\n  return out;\n}\n/**\n * 设置向量的两个项\n * @param {Vector2} out\n * @param {number} a\n * @param {number} b\n * @return {Vector2} 结果\n */\n\n\nfunction set(out, a, b) {\n  out[0] = a;\n  out[1] = b;\n  return out;\n}\n/**\n * 向量相加\n * @param {Vector2} out\n * @param {Vector2} v1\n * @param {Vector2} v2\n */\n\n\nfunction add(out, v1, v2) {\n  out[0] = v1[0] + v2[0];\n  out[1] = v1[1] + v2[1];\n  return out;\n}\n/**\n * 向量缩放后相加\n * @param {Vector2} out\n * @param {Vector2} v1\n * @param {Vector2} v2\n * @param {number} a\n */\n\n\nfunction scaleAndAdd(out, v1, v2, a) {\n  out[0] = v1[0] + v2[0] * a;\n  out[1] = v1[1] + v2[1] * a;\n  return out;\n}\n/**\n * 向量相减\n * @param {Vector2} out\n * @param {Vector2} v1\n * @param {Vector2} v2\n */\n\n\nfunction sub(out, v1, v2) {\n  out[0] = v1[0] - v2[0];\n  out[1] = v1[1] - v2[1];\n  return out;\n}\n/**\n * 向量长度\n * @param {Vector2} v\n * @return {number}\n */\n\n\nfunction len(v) {\n  return Math.sqrt(lenSquare(v));\n}\n\nvar length = len; // jshint ignore:line\n\n/**\n * 向量长度平方\n * @param {Vector2} v\n * @return {number}\n */\n\nfunction lenSquare(v) {\n  return v[0] * v[0] + v[1] * v[1];\n}\n\nvar lengthSquare = lenSquare;\n/**\n * 向量乘法\n * @param {Vector2} out\n * @param {Vector2} v1\n * @param {Vector2} v2\n */\n\nfunction mul(out, v1, v2) {\n  out[0] = v1[0] * v2[0];\n  out[1] = v1[1] * v2[1];\n  return out;\n}\n/**\n * 向量除法\n * @param {Vector2} out\n * @param {Vector2} v1\n * @param {Vector2} v2\n */\n\n\nfunction div(out, v1, v2) {\n  out[0] = v1[0] / v2[0];\n  out[1] = v1[1] / v2[1];\n  return out;\n}\n/**\n * 向量点乘\n * @param {Vector2} v1\n * @param {Vector2} v2\n * @return {number}\n */\n\n\nfunction dot(v1, v2) {\n  return v1[0] * v2[0] + v1[1] * v2[1];\n}\n/**\n * 向量缩放\n * @param {Vector2} out\n * @param {Vector2} v\n * @param {number} s\n */\n\n\nfunction scale(out, v, s) {\n  out[0] = v[0] * s;\n  out[1] = v[1] * s;\n  return out;\n}\n/**\n * 向量归一化\n * @param {Vector2} out\n * @param {Vector2} v\n */\n\n\nfunction normalize(out, v) {\n  var d = len(v);\n\n  if (d === 0) {\n    out[0] = 0;\n    out[1] = 0;\n  } else {\n    out[0] = v[0] / d;\n    out[1] = v[1] / d;\n  }\n\n  return out;\n}\n/**\n * 计算向量间距离\n * @param {Vector2} v1\n * @param {Vector2} v2\n * @return {number}\n */\n\n\nfunction distance(v1, v2) {\n  return Math.sqrt((v1[0] - v2[0]) * (v1[0] - v2[0]) + (v1[1] - v2[1]) * (v1[1] - v2[1]));\n}\n\nvar dist = distance;\n/**\n * 向量距离平方\n * @param {Vector2} v1\n * @param {Vector2} v2\n * @return {number}\n */\n\nfunction distanceSquare(v1, v2) {\n  return (v1[0] - v2[0]) * (v1[0] - v2[0]) + (v1[1] - v2[1]) * (v1[1] - v2[1]);\n}\n\nvar distSquare = distanceSquare;\n/**\n * 求负向量\n * @param {Vector2} out\n * @param {Vector2} v\n */\n\nfunction negate(out, v) {\n  out[0] = -v[0];\n  out[1] = -v[1];\n  return out;\n}\n/**\n * 插值两个点\n * @param {Vector2} out\n * @param {Vector2} v1\n * @param {Vector2} v2\n * @param {number} t\n */\n\n\nfunction lerp(out, v1, v2, t) {\n  out[0] = v1[0] + t * (v2[0] - v1[0]);\n  out[1] = v1[1] + t * (v2[1] - v1[1]);\n  return out;\n}\n/**\n * 矩阵左乘向量\n * @param {Vector2} out\n * @param {Vector2} v\n * @param {Vector2} m\n */\n\n\nfunction applyTransform(out, v, m) {\n  var x = v[0];\n  var y = v[1];\n  out[0] = m[0] * x + m[2] * y + m[4];\n  out[1] = m[1] * x + m[3] * y + m[5];\n  return out;\n}\n/**\n * 求两个向量最小值\n * @param  {Vector2} out\n * @param  {Vector2} v1\n * @param  {Vector2} v2\n */\n\n\nfunction min(out, v1, v2) {\n  out[0] = Math.min(v1[0], v2[0]);\n  out[1] = Math.min(v1[1], v2[1]);\n  return out;\n}\n/**\n * 求两个向量最大值\n * @param  {Vector2} out\n * @param  {Vector2} v1\n * @param  {Vector2} v2\n */\n\n\nfunction max(out, v1, v2) {\n  out[0] = Math.max(v1[0], v2[0]);\n  out[1] = Math.max(v1[1], v2[1]);\n  return out;\n}\n\nexports.create = create;\nexports.copy = copy;\nexports.clone = clone;\nexports.set = set;\nexports.add = add;\nexports.scaleAndAdd = scaleAndAdd;\nexports.sub = sub;\nexports.len = len;\nexports.length = length;\nexports.lenSquare = lenSquare;\nexports.lengthSquare = lengthSquare;\nexports.mul = mul;\nexports.div = div;\nexports.dot = dot;\nexports.scale = scale;\nexports.normalize = normalize;\nexports.distance = distance;\nexports.dist = dist;\nexports.distanceSquare = distanceSquare;\nexports.distSquare = distSquare;\nexports.negate = negate;\nexports.lerp = lerp;\nexports.applyTransform = applyTransform;\nexports.min = min;\nexports.max = max;\n\n/***/ }),\n/* 3 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar vec2 = __webpack_require__(2);\n\nvar matrix = __webpack_require__(10);\n\n/**\n * @module echarts/core/BoundingRect\n */\nvar v2ApplyTransform = vec2.applyTransform;\nvar mathMin = Math.min;\nvar mathMax = Math.max;\n/**\n * @alias module:echarts/core/BoundingRect\n */\n\nfunction BoundingRect(x, y, width, height) {\n  if (width < 0) {\n    x = x + width;\n    width = -width;\n  }\n\n  if (height < 0) {\n    y = y + height;\n    height = -height;\n  }\n  /**\n   * @type {number}\n   */\n\n\n  this.x = x;\n  /**\n   * @type {number}\n   */\n\n  this.y = y;\n  /**\n   * @type {number}\n   */\n\n  this.width = width;\n  /**\n   * @type {number}\n   */\n\n  this.height = height;\n}\n\nBoundingRect.prototype = {\n  constructor: BoundingRect,\n\n  /**\n   * @param {module:echarts/core/BoundingRect} other\n   */\n  union: function (other) {\n    var x = mathMin(other.x, this.x);\n    var y = mathMin(other.y, this.y);\n    this.width = mathMax(other.x + other.width, this.x + this.width) - x;\n    this.height = mathMax(other.y + other.height, this.y + this.height) - y;\n    this.x = x;\n    this.y = y;\n  },\n\n  /**\n   * @param {Array.<number>} m\n   * @methods\n   */\n  applyTransform: function () {\n    var lt = [];\n    var rb = [];\n    var lb = [];\n    var rt = [];\n    return function (m) {\n      // In case usage like this\n      // el.getBoundingRect().applyTransform(el.transform)\n      // And element has no transform\n      if (!m) {\n        return;\n      }\n\n      lt[0] = lb[0] = this.x;\n      lt[1] = rt[1] = this.y;\n      rb[0] = rt[0] = this.x + this.width;\n      rb[1] = lb[1] = this.y + this.height;\n      v2ApplyTransform(lt, lt, m);\n      v2ApplyTransform(rb, rb, m);\n      v2ApplyTransform(lb, lb, m);\n      v2ApplyTransform(rt, rt, m);\n      this.x = mathMin(lt[0], rb[0], lb[0], rt[0]);\n      this.y = mathMin(lt[1], rb[1], lb[1], rt[1]);\n      var maxX = mathMax(lt[0], rb[0], lb[0], rt[0]);\n      var maxY = mathMax(lt[1], rb[1], lb[1], rt[1]);\n      this.width = maxX - this.x;\n      this.height = maxY - this.y;\n    };\n  }(),\n\n  /**\n   * Calculate matrix of transforming from self to target rect\n   * @param  {module:zrender/core/BoundingRect} b\n   * @return {Array.<number>}\n   */\n  calculateTransform: function (b) {\n    var a = this;\n    var sx = b.width / a.width;\n    var sy = b.height / a.height;\n    var m = matrix.create(); // 矩阵右乘\n\n    matrix.translate(m, m, [-a.x, -a.y]);\n    matrix.scale(m, m, [sx, sy]);\n    matrix.translate(m, m, [b.x, b.y]);\n    return m;\n  },\n\n  /**\n   * @param {(module:echarts/core/BoundingRect|Object)} b\n   * @return {boolean}\n   */\n  intersect: function (b) {\n    if (!b) {\n      return false;\n    }\n\n    if (!(b instanceof BoundingRect)) {\n      // Normalize negative width/height.\n      b = BoundingRect.create(b);\n    }\n\n    var a = this;\n    var ax0 = a.x;\n    var ax1 = a.x + a.width;\n    var ay0 = a.y;\n    var ay1 = a.y + a.height;\n    var bx0 = b.x;\n    var bx1 = b.x + b.width;\n    var by0 = b.y;\n    var by1 = b.y + b.height;\n    return !(ax1 < bx0 || bx1 < ax0 || ay1 < by0 || by1 < ay0);\n  },\n  contain: function (x, y) {\n    var rect = this;\n    return x >= rect.x && x <= rect.x + rect.width && y >= rect.y && y <= rect.y + rect.height;\n  },\n\n  /**\n   * @return {module:echarts/core/BoundingRect}\n   */\n  clone: function () {\n    return new BoundingRect(this.x, this.y, this.width, this.height);\n  },\n\n  /**\n   * Copy from another rect\n   */\n  copy: function (other) {\n    this.x = other.x;\n    this.y = other.y;\n    this.width = other.width;\n    this.height = other.height;\n  },\n  plain: function () {\n    return {\n      x: this.x,\n      y: this.y,\n      width: this.width,\n      height: this.height\n    };\n  }\n};\n/**\n * @param {Object|module:zrender/core/BoundingRect} rect\n * @param {number} rect.x\n * @param {number} rect.y\n * @param {number} rect.width\n * @param {number} rect.height\n * @return {module:zrender/core/BoundingRect}\n */\n\nBoundingRect.create = function (rect) {\n  return new BoundingRect(rect.x, rect.y, rect.width, rect.height);\n};\n\nvar _default = BoundingRect;\nmodule.exports = _default;\n\n/***/ }),\n/* 4 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar _vector = __webpack_require__(2);\n\nvar v2Create = _vector.create;\nvar v2DistSquare = _vector.distSquare;\n\n/**\n * 曲线辅助模块\n * @module zrender/core/curve\n * @author pissang(https://www.github.com/pissang)\n */\nvar mathPow = Math.pow;\nvar mathSqrt = Math.sqrt;\nvar EPSILON = 1e-8;\nvar EPSILON_NUMERIC = 1e-4;\nvar THREE_SQRT = mathSqrt(3);\nvar ONE_THIRD = 1 / 3; // 临时变量\n\nvar _v0 = v2Create();\n\nvar _v1 = v2Create();\n\nvar _v2 = v2Create();\n\nfunction isAroundZero(val) {\n  return val > -EPSILON && val < EPSILON;\n}\n\nfunction isNotAroundZero(val) {\n  return val > EPSILON || val < -EPSILON;\n}\n/**\n * 计算三次贝塞尔值\n * @memberOf module:zrender/core/curve\n * @param  {number} p0\n * @param  {number} p1\n * @param  {number} p2\n * @param  {number} p3\n * @param  {number} t\n * @return {number}\n */\n\n\nfunction cubicAt(p0, p1, p2, p3, t) {\n  var onet = 1 - t;\n  return onet * onet * (onet * p0 + 3 * t * p1) + t * t * (t * p3 + 3 * onet * p2);\n}\n/**\n * 计算三次贝塞尔导数值\n * @memberOf module:zrender/core/curve\n * @param  {number} p0\n * @param  {number} p1\n * @param  {number} p2\n * @param  {number} p3\n * @param  {number} t\n * @return {number}\n */\n\n\nfunction cubicDerivativeAt(p0, p1, p2, p3, t) {\n  var onet = 1 - t;\n  return 3 * (((p1 - p0) * onet + 2 * (p2 - p1) * t) * onet + (p3 - p2) * t * t);\n}\n/**\n * 计算三次贝塞尔方程根，使用盛金公式\n * @memberOf module:zrender/core/curve\n * @param  {number} p0\n * @param  {number} p1\n * @param  {number} p2\n * @param  {number} p3\n * @param  {number} val\n * @param  {Array.<number>} roots\n * @return {number} 有效根数目\n */\n\n\nfunction cubicRootAt(p0, p1, p2, p3, val, roots) {\n  // Evaluate roots of cubic functions\n  var a = p3 + 3 * (p1 - p2) - p0;\n  var b = 3 * (p2 - p1 * 2 + p0);\n  var c = 3 * (p1 - p0);\n  var d = p0 - val;\n  var A = b * b - 3 * a * c;\n  var B = b * c - 9 * a * d;\n  var C = c * c - 3 * b * d;\n  var n = 0;\n\n  if (isAroundZero(A) && isAroundZero(B)) {\n    if (isAroundZero(b)) {\n      roots[0] = 0;\n    } else {\n      var t1 = -c / b; //t1, t2, t3, b is not zero\n\n      if (t1 >= 0 && t1 <= 1) {\n        roots[n++] = t1;\n      }\n    }\n  } else {\n    var disc = B * B - 4 * A * C;\n\n    if (isAroundZero(disc)) {\n      var K = B / A;\n      var t1 = -b / a + K; // t1, a is not zero\n\n      var t2 = -K / 2; // t2, t3\n\n      if (t1 >= 0 && t1 <= 1) {\n        roots[n++] = t1;\n      }\n\n      if (t2 >= 0 && t2 <= 1) {\n        roots[n++] = t2;\n      }\n    } else if (disc > 0) {\n      var discSqrt = mathSqrt(disc);\n      var Y1 = A * b + 1.5 * a * (-B + discSqrt);\n      var Y2 = A * b + 1.5 * a * (-B - discSqrt);\n\n      if (Y1 < 0) {\n        Y1 = -mathPow(-Y1, ONE_THIRD);\n      } else {\n        Y1 = mathPow(Y1, ONE_THIRD);\n      }\n\n      if (Y2 < 0) {\n        Y2 = -mathPow(-Y2, ONE_THIRD);\n      } else {\n        Y2 = mathPow(Y2, ONE_THIRD);\n      }\n\n      var t1 = (-b - (Y1 + Y2)) / (3 * a);\n\n      if (t1 >= 0 && t1 <= 1) {\n        roots[n++] = t1;\n      }\n    } else {\n      var T = (2 * A * b - 3 * a * B) / (2 * mathSqrt(A * A * A));\n      var theta = Math.acos(T) / 3;\n      var ASqrt = mathSqrt(A);\n      var tmp = Math.cos(theta);\n      var t1 = (-b - 2 * ASqrt * tmp) / (3 * a);\n      var t2 = (-b + ASqrt * (tmp + THREE_SQRT * Math.sin(theta))) / (3 * a);\n      var t3 = (-b + ASqrt * (tmp - THREE_SQRT * Math.sin(theta))) / (3 * a);\n\n      if (t1 >= 0 && t1 <= 1) {\n        roots[n++] = t1;\n      }\n\n      if (t2 >= 0 && t2 <= 1) {\n        roots[n++] = t2;\n      }\n\n      if (t3 >= 0 && t3 <= 1) {\n        roots[n++] = t3;\n      }\n    }\n  }\n\n  return n;\n}\n/**\n * 计算三次贝塞尔方程极限值的位置\n * @memberOf module:zrender/core/curve\n * @param  {number} p0\n * @param  {number} p1\n * @param  {number} p2\n * @param  {number} p3\n * @param  {Array.<number>} extrema\n * @return {number} 有效数目\n */\n\n\nfunction cubicExtrema(p0, p1, p2, p3, extrema) {\n  var b = 6 * p2 - 12 * p1 + 6 * p0;\n  var a = 9 * p1 + 3 * p3 - 3 * p0 - 9 * p2;\n  var c = 3 * p1 - 3 * p0;\n  var n = 0;\n\n  if (isAroundZero(a)) {\n    if (isNotAroundZero(b)) {\n      var t1 = -c / b;\n\n      if (t1 >= 0 && t1 <= 1) {\n        extrema[n++] = t1;\n      }\n    }\n  } else {\n    var disc = b * b - 4 * a * c;\n\n    if (isAroundZero(disc)) {\n      extrema[0] = -b / (2 * a);\n    } else if (disc > 0) {\n      var discSqrt = mathSqrt(disc);\n      var t1 = (-b + discSqrt) / (2 * a);\n      var t2 = (-b - discSqrt) / (2 * a);\n\n      if (t1 >= 0 && t1 <= 1) {\n        extrema[n++] = t1;\n      }\n\n      if (t2 >= 0 && t2 <= 1) {\n        extrema[n++] = t2;\n      }\n    }\n  }\n\n  return n;\n}\n/**\n * 细分三次贝塞尔曲线\n * @memberOf module:zrender/core/curve\n * @param  {number} p0\n * @param  {number} p1\n * @param  {number} p2\n * @param  {number} p3\n * @param  {number} t\n * @param  {Array.<number>} out\n */\n\n\nfunction cubicSubdivide(p0, p1, p2, p3, t, out) {\n  var p01 = (p1 - p0) * t + p0;\n  var p12 = (p2 - p1) * t + p1;\n  var p23 = (p3 - p2) * t + p2;\n  var p012 = (p12 - p01) * t + p01;\n  var p123 = (p23 - p12) * t + p12;\n  var p0123 = (p123 - p012) * t + p012; // Seg0\n\n  out[0] = p0;\n  out[1] = p01;\n  out[2] = p012;\n  out[3] = p0123; // Seg1\n\n  out[4] = p0123;\n  out[5] = p123;\n  out[6] = p23;\n  out[7] = p3;\n}\n/**\n * 投射点到三次贝塞尔曲线上，返回投射距离。\n * 投射点有可能会有一个或者多个，这里只返回其中距离最短的一个。\n * @param {number} x0\n * @param {number} y0\n * @param {number} x1\n * @param {number} y1\n * @param {number} x2\n * @param {number} y2\n * @param {number} x3\n * @param {number} y3\n * @param {number} x\n * @param {number} y\n * @param {Array.<number>} [out] 投射点\n * @return {number}\n */\n\n\nfunction cubicProjectPoint(x0, y0, x1, y1, x2, y2, x3, y3, x, y, out) {\n  // http://pomax.github.io/bezierinfo/#projections\n  var t;\n  var interval = 0.005;\n  var d = Infinity;\n  var prev;\n  var next;\n  var d1;\n  var d2;\n  _v0[0] = x;\n  _v0[1] = y; // 先粗略估计一下可能的最小距离的 t 值\n  // PENDING\n\n  for (var _t = 0; _t < 1; _t += 0.05) {\n    _v1[0] = cubicAt(x0, x1, x2, x3, _t);\n    _v1[1] = cubicAt(y0, y1, y2, y3, _t);\n    d1 = v2DistSquare(_v0, _v1);\n\n    if (d1 < d) {\n      t = _t;\n      d = d1;\n    }\n  }\n\n  d = Infinity; // At most 32 iteration\n\n  for (var i = 0; i < 32; i++) {\n    if (interval < EPSILON_NUMERIC) {\n      break;\n    }\n\n    prev = t - interval;\n    next = t + interval; // t - interval\n\n    _v1[0] = cubicAt(x0, x1, x2, x3, prev);\n    _v1[1] = cubicAt(y0, y1, y2, y3, prev);\n    d1 = v2DistSquare(_v1, _v0);\n\n    if (prev >= 0 && d1 < d) {\n      t = prev;\n      d = d1;\n    } else {\n      // t + interval\n      _v2[0] = cubicAt(x0, x1, x2, x3, next);\n      _v2[1] = cubicAt(y0, y1, y2, y3, next);\n      d2 = v2DistSquare(_v2, _v0);\n\n      if (next <= 1 && d2 < d) {\n        t = next;\n        d = d2;\n      } else {\n        interval *= 0.5;\n      }\n    }\n  } // t\n\n\n  if (out) {\n    out[0] = cubicAt(x0, x1, x2, x3, t);\n    out[1] = cubicAt(y0, y1, y2, y3, t);\n  } // console.log(interval, i);\n\n\n  return mathSqrt(d);\n}\n/**\n * 计算二次方贝塞尔值\n * @param  {number} p0\n * @param  {number} p1\n * @param  {number} p2\n * @param  {number} t\n * @return {number}\n */\n\n\nfunction quadraticAt(p0, p1, p2, t) {\n  var onet = 1 - t;\n  return onet * (onet * p0 + 2 * t * p1) + t * t * p2;\n}\n/**\n * 计算二次方贝塞尔导数值\n * @param  {number} p0\n * @param  {number} p1\n * @param  {number} p2\n * @param  {number} t\n * @return {number}\n */\n\n\nfunction quadraticDerivativeAt(p0, p1, p2, t) {\n  return 2 * ((1 - t) * (p1 - p0) + t * (p2 - p1));\n}\n/**\n * 计算二次方贝塞尔方程根\n * @param  {number} p0\n * @param  {number} p1\n * @param  {number} p2\n * @param  {number} t\n * @param  {Array.<number>} roots\n * @return {number} 有效根数目\n */\n\n\nfunction quadraticRootAt(p0, p1, p2, val, roots) {\n  var a = p0 - 2 * p1 + p2;\n  var b = 2 * (p1 - p0);\n  var c = p0 - val;\n  var n = 0;\n\n  if (isAroundZero(a)) {\n    if (isNotAroundZero(b)) {\n      var t1 = -c / b;\n\n      if (t1 >= 0 && t1 <= 1) {\n        roots[n++] = t1;\n      }\n    }\n  } else {\n    var disc = b * b - 4 * a * c;\n\n    if (isAroundZero(disc)) {\n      var t1 = -b / (2 * a);\n\n      if (t1 >= 0 && t1 <= 1) {\n        roots[n++] = t1;\n      }\n    } else if (disc > 0) {\n      var discSqrt = mathSqrt(disc);\n      var t1 = (-b + discSqrt) / (2 * a);\n      var t2 = (-b - discSqrt) / (2 * a);\n\n      if (t1 >= 0 && t1 <= 1) {\n        roots[n++] = t1;\n      }\n\n      if (t2 >= 0 && t2 <= 1) {\n        roots[n++] = t2;\n      }\n    }\n  }\n\n  return n;\n}\n/**\n * 计算二次贝塞尔方程极限值\n * @memberOf module:zrender/core/curve\n * @param  {number} p0\n * @param  {number} p1\n * @param  {number} p2\n * @return {number}\n */\n\n\nfunction quadraticExtremum(p0, p1, p2) {\n  var divider = p0 + p2 - 2 * p1;\n\n  if (divider === 0) {\n    // p1 is center of p0 and p2\n    return 0.5;\n  } else {\n    return (p0 - p1) / divider;\n  }\n}\n/**\n * 细分二次贝塞尔曲线\n * @memberOf module:zrender/core/curve\n * @param  {number} p0\n * @param  {number} p1\n * @param  {number} p2\n * @param  {number} t\n * @param  {Array.<number>} out\n */\n\n\nfunction quadraticSubdivide(p0, p1, p2, t, out) {\n  var p01 = (p1 - p0) * t + p0;\n  var p12 = (p2 - p1) * t + p1;\n  var p012 = (p12 - p01) * t + p01; // Seg0\n\n  out[0] = p0;\n  out[1] = p01;\n  out[2] = p012; // Seg1\n\n  out[3] = p012;\n  out[4] = p12;\n  out[5] = p2;\n}\n/**\n * 投射点到二次贝塞尔曲线上，返回投射距离。\n * 投射点有可能会有一个或者多个，这里只返回其中距离最短的一个。\n * @param {number} x0\n * @param {number} y0\n * @param {number} x1\n * @param {number} y1\n * @param {number} x2\n * @param {number} y2\n * @param {number} x\n * @param {number} y\n * @param {Array.<number>} out 投射点\n * @return {number}\n */\n\n\nfunction quadraticProjectPoint(x0, y0, x1, y1, x2, y2, x, y, out) {\n  // http://pomax.github.io/bezierinfo/#projections\n  var t;\n  var interval = 0.005;\n  var d = Infinity;\n  _v0[0] = x;\n  _v0[1] = y; // 先粗略估计一下可能的最小距离的 t 值\n  // PENDING\n\n  for (var _t = 0; _t < 1; _t += 0.05) {\n    _v1[0] = quadraticAt(x0, x1, x2, _t);\n    _v1[1] = quadraticAt(y0, y1, y2, _t);\n    var d1 = v2DistSquare(_v0, _v1);\n\n    if (d1 < d) {\n      t = _t;\n      d = d1;\n    }\n  }\n\n  d = Infinity; // At most 32 iteration\n\n  for (var i = 0; i < 32; i++) {\n    if (interval < EPSILON_NUMERIC) {\n      break;\n    }\n\n    var prev = t - interval;\n    var next = t + interval; // t - interval\n\n    _v1[0] = quadraticAt(x0, x1, x2, prev);\n    _v1[1] = quadraticAt(y0, y1, y2, prev);\n    var d1 = v2DistSquare(_v1, _v0);\n\n    if (prev >= 0 && d1 < d) {\n      t = prev;\n      d = d1;\n    } else {\n      // t + interval\n      _v2[0] = quadraticAt(x0, x1, x2, next);\n      _v2[1] = quadraticAt(y0, y1, y2, next);\n      var d2 = v2DistSquare(_v2, _v0);\n\n      if (next <= 1 && d2 < d) {\n        t = next;\n        d = d2;\n      } else {\n        interval *= 0.5;\n      }\n    }\n  } // t\n\n\n  if (out) {\n    out[0] = quadraticAt(x0, x1, x2, t);\n    out[1] = quadraticAt(y0, y1, y2, t);\n  } // console.log(interval, i);\n\n\n  return mathSqrt(d);\n}\n\nexports.cubicAt = cubicAt;\nexports.cubicDerivativeAt = cubicDerivativeAt;\nexports.cubicRootAt = cubicRootAt;\nexports.cubicExtrema = cubicExtrema;\nexports.cubicSubdivide = cubicSubdivide;\nexports.cubicProjectPoint = cubicProjectPoint;\nexports.quadraticAt = quadraticAt;\nexports.quadraticDerivativeAt = quadraticDerivativeAt;\nexports.quadraticRootAt = quadraticRootAt;\nexports.quadraticExtremum = quadraticExtremum;\nexports.quadraticSubdivide = quadraticSubdivide;\nexports.quadraticProjectPoint = quadraticProjectPoint;\n\n/***/ }),\n/* 5 */\n/***/ (function(module, exports) {\n\nmodule.exports = __WEBPACK_EXTERNAL_MODULE__5__;\n\n/***/ }),\n/* 6 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(global) {\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n// (1) The code `if (__DEV__) ...` can be removed by build tool.\n// (2) If intend to use `__DEV__`, this module should be imported. Use a global\n// variable `__DEV__` may cause that miss the declaration (see #6535), or the\n// declaration is behind of the using position (for example in `Model.extent`,\n// And tools like rollup can not analysis the dependency if not import).\nvar dev; // In browser\n\nif (typeof window !== 'undefined') {\n  dev = window.__DEV__;\n} // In node\nelse if (typeof global !== 'undefined') {\n    dev = global.__DEV__;\n  }\n\nif (typeof dev === 'undefined') {\n  dev = true;\n}\n\nvar __DEV__ = dev;\nexports.__DEV__ = __DEV__;\n/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(34)))\n\n/***/ }),\n/* 7 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar zrUtil = __webpack_require__(0);\n\nvar Style = __webpack_require__(42);\n\nvar Element = __webpack_require__(17);\n\nvar RectText = __webpack_require__(50);\n\n/**\n * 可绘制的图形基类\n * Base class of all displayable graphic objects\n * @module zrender/graphic/Displayable\n */\n\n/**\n * @alias module:zrender/graphic/Displayable\n * @extends module:zrender/Element\n * @extends module:zrender/graphic/mixin/RectText\n */\nfunction Displayable(opts) {\n  opts = opts || {};\n  Element.call(this, opts); // Extend properties\n\n  for (var name in opts) {\n    if (opts.hasOwnProperty(name) && name !== 'style') {\n      this[name] = opts[name];\n    }\n  }\n  /**\n   * @type {module:zrender/graphic/Style}\n   */\n\n\n  this.style = new Style(opts.style, this);\n  this._rect = null; // Shapes for cascade clipping.\n\n  this.__clipPaths = []; // FIXME Stateful must be mixined after style is setted\n  // Stateful.call(this, opts);\n}\n\nDisplayable.prototype = {\n  constructor: Displayable,\n  type: 'displayable',\n\n  /**\n   * Displayable 是否为脏，Painter 中会根据该标记判断是否需要是否需要重新绘制\n   * Dirty flag. From which painter will determine if this displayable object needs brush\n   * @name module:zrender/graphic/Displayable#__dirty\n   * @type {boolean}\n   */\n  __dirty: true,\n\n  /**\n   * 图形是否可见，为true时不绘制图形，但是仍能触发鼠标事件\n   * If ignore drawing of the displayable object. Mouse event will still be triggered\n   * @name module:/zrender/graphic/Displayable#invisible\n   * @type {boolean}\n   * @default false\n   */\n  invisible: false,\n\n  /**\n   * @name module:/zrender/graphic/Displayable#z\n   * @type {number}\n   * @default 0\n   */\n  z: 0,\n\n  /**\n   * @name module:/zrender/graphic/Displayable#z\n   * @type {number}\n   * @default 0\n   */\n  z2: 0,\n\n  /**\n   * z层level，决定绘画在哪层canvas中\n   * @name module:/zrender/graphic/Displayable#zlevel\n   * @type {number}\n   * @default 0\n   */\n  zlevel: 0,\n\n  /**\n   * 是否可拖拽\n   * @name module:/zrender/graphic/Displayable#draggable\n   * @type {boolean}\n   * @default false\n   */\n  draggable: false,\n\n  /**\n   * 是否正在拖拽\n   * @name module:/zrender/graphic/Displayable#draggable\n   * @type {boolean}\n   * @default false\n   */\n  dragging: false,\n\n  /**\n   * 是否相应鼠标事件\n   * @name module:/zrender/graphic/Displayable#silent\n   * @type {boolean}\n   * @default false\n   */\n  silent: false,\n\n  /**\n   * If enable culling\n   * @type {boolean}\n   * @default false\n   */\n  culling: false,\n\n  /**\n   * Mouse cursor when hovered\n   * @name module:/zrender/graphic/Displayable#cursor\n   * @type {string}\n   */\n  cursor: 'pointer',\n\n  /**\n   * If hover area is bounding rect\n   * @name module:/zrender/graphic/Displayable#rectHover\n   * @type {string}\n   */\n  rectHover: false,\n\n  /**\n   * Render the element progressively when the value >= 0,\n   * usefull for large data.\n   * @type {boolean}\n   */\n  progressive: false,\n\n  /**\n   * @type {boolean}\n   */\n  incremental: false,\n\n  /**\n   * Scale ratio for global scale.\n   * @type {boolean}\n   */\n  globalScaleRatio: 1,\n  beforeBrush: function (ctx) {},\n  afterBrush: function (ctx) {},\n\n  /**\n   * 图形绘制方法\n   * @param {CanvasRenderingContext2D} ctx\n   */\n  // Interface\n  brush: function (ctx, prevEl) {},\n\n  /**\n   * 获取最小包围盒\n   * @return {module:zrender/core/BoundingRect}\n   */\n  // Interface\n  getBoundingRect: function () {},\n\n  /**\n   * 判断坐标 x, y 是否在图形上\n   * If displayable element contain coord x, y\n   * @param  {number} x\n   * @param  {number} y\n   * @return {boolean}\n   */\n  contain: function (x, y) {\n    return this.rectContain(x, y);\n  },\n\n  /**\n   * @param  {Function} cb\n   * @param  {}   context\n   */\n  traverse: function (cb, context) {\n    cb.call(context, this);\n  },\n\n  /**\n   * 判断坐标 x, y 是否在图形的包围盒上\n   * If bounding rect of element contain coord x, y\n   * @param  {number} x\n   * @param  {number} y\n   * @return {boolean}\n   */\n  rectContain: function (x, y) {\n    var coord = this.transformCoordToLocal(x, y);\n    var rect = this.getBoundingRect();\n    return rect.contain(coord[0], coord[1]);\n  },\n\n  /**\n   * 标记图形元素为脏，并且在下一帧重绘\n   * Mark displayable element dirty and refresh next frame\n   */\n  dirty: function () {\n    this.__dirty = this.__dirtyText = true;\n    this._rect = null;\n    this.__zr && this.__zr.refresh();\n  },\n\n  /**\n   * 图形是否会触发事件\n   * If displayable object binded any event\n   * @return {boolean}\n   */\n  // TODO, 通过 bind 绑定的事件\n  // isSilent: function () {\n  //     return !(\n  //         this.hoverable || this.draggable\n  //         || this.onmousemove || this.onmouseover || this.onmouseout\n  //         || this.onmousedown || this.onmouseup || this.onclick\n  //         || this.ondragenter || this.ondragover || this.ondragleave\n  //         || this.ondrop\n  //     );\n  // },\n\n  /**\n   * Alias for animate('style')\n   * @param {boolean} loop\n   */\n  animateStyle: function (loop) {\n    return this.animate('style', loop);\n  },\n  attrKV: function (key, value) {\n    if (key !== 'style') {\n      Element.prototype.attrKV.call(this, key, value);\n    } else {\n      this.style.set(value);\n    }\n  },\n\n  /**\n   * @param {Object|string} key\n   * @param {*} value\n   */\n  setStyle: function (key, value) {\n    this.style.set(key, value);\n    this.dirty(false);\n    return this;\n  },\n\n  /**\n   * Use given style object\n   * @param  {Object} obj\n   */\n  useStyle: function (obj) {\n    this.style = new Style(obj, this);\n    this.dirty(false);\n    return this;\n  }\n};\nzrUtil.inherits(Displayable, Element);\nzrUtil.mixin(Displayable, RectText); // zrUtil.mixin(Displayable, Stateful);\n\nvar _default = Displayable;\nmodule.exports = _default;\n\n/***/ }),\n/* 8 */\n/***/ (function(module, exports) {\n\nvar ContextCachedBy = {\n  NONE: 0,\n  STYLE_BIND: 1,\n  PLAIN_TEXT: 2\n}; // Avoid confused with 0/false.\n\nvar WILL_BE_RESTORED = 9;\nexports.ContextCachedBy = ContextCachedBy;\nexports.WILL_BE_RESTORED = WILL_BE_RESTORED;\n\n/***/ }),\n/* 9 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar curve = __webpack_require__(4);\n\nvar vec2 = __webpack_require__(2);\n\nvar bbox = __webpack_require__(51);\n\nvar BoundingRect = __webpack_require__(3);\n\nvar _config = __webpack_require__(21);\n\nvar dpr = _config.devicePixelRatio;\n\n/**\n * Path 代理，可以在`buildPath`中用于替代`ctx`, 会保存每个path操作的命令到pathCommands属性中\n * 可以用于 isInsidePath 判断以及获取boundingRect\n *\n * @module zrender/core/PathProxy\n * @author Yi Shen (http://www.github.com/pissang)\n */\n// TODO getTotalLength, getPointAtLength\nvar CMD = {\n  M: 1,\n  L: 2,\n  C: 3,\n  Q: 4,\n  A: 5,\n  Z: 6,\n  // Rect\n  R: 7\n}; // var CMD_MEM_SIZE = {\n//     M: 3,\n//     L: 3,\n//     C: 7,\n//     Q: 5,\n//     A: 9,\n//     R: 5,\n//     Z: 1\n// };\n\nvar min = [];\nvar max = [];\nvar min2 = [];\nvar max2 = [];\nvar mathMin = Math.min;\nvar mathMax = Math.max;\nvar mathCos = Math.cos;\nvar mathSin = Math.sin;\nvar mathSqrt = Math.sqrt;\nvar mathAbs = Math.abs;\nvar hasTypedArray = typeof Float32Array !== 'undefined';\n/**\n * @alias module:zrender/core/PathProxy\n * @constructor\n */\n\nvar PathProxy = function (notSaveData) {\n  this._saveData = !(notSaveData || false);\n\n  if (this._saveData) {\n    /**\n     * Path data. Stored as flat array\n     * @type {Array.<Object>}\n     */\n    this.data = [];\n  }\n\n  this._ctx = null;\n};\n/**\n * 快速计算Path包围盒（并不是最小包围盒）\n * @return {Object}\n */\n\n\nPathProxy.prototype = {\n  constructor: PathProxy,\n  _xi: 0,\n  _yi: 0,\n  _x0: 0,\n  _y0: 0,\n  // Unit x, Unit y. Provide for avoiding drawing that too short line segment\n  _ux: 0,\n  _uy: 0,\n  _len: 0,\n  _lineDash: null,\n  _dashOffset: 0,\n  _dashIdx: 0,\n  _dashSum: 0,\n\n  /**\n   * @readOnly\n   */\n  setScale: function (sx, sy) {\n    this._ux = mathAbs(1 / dpr / sx) || 0;\n    this._uy = mathAbs(1 / dpr / sy) || 0;\n  },\n  getContext: function () {\n    return this._ctx;\n  },\n\n  /**\n   * @param  {CanvasRenderingContext2D} ctx\n   * @return {module:zrender/core/PathProxy}\n   */\n  beginPath: function (ctx) {\n    this._ctx = ctx;\n    ctx && ctx.beginPath();\n    ctx && (this.dpr = ctx.dpr); // Reset\n\n    if (this._saveData) {\n      this._len = 0;\n    }\n\n    if (this._lineDash) {\n      this._lineDash = null;\n      this._dashOffset = 0;\n    }\n\n    return this;\n  },\n\n  /**\n   * @param  {number} x\n   * @param  {number} y\n   * @return {module:zrender/core/PathProxy}\n   */\n  moveTo: function (x, y) {\n    this.addData(CMD.M, x, y);\n    this._ctx && this._ctx.moveTo(x, y); // x0, y0, xi, yi 是记录在 _dashedXXXXTo 方法中使用\n    // xi, yi 记录当前点, x0, y0 在 closePath 的时候回到起始点。\n    // 有可能在 beginPath 之后直接调用 lineTo，这时候 x0, y0 需要\n    // 在 lineTo 方法中记录，这里先不考虑这种情况，dashed line 也只在 IE10- 中不支持\n\n    this._x0 = x;\n    this._y0 = y;\n    this._xi = x;\n    this._yi = y;\n    return this;\n  },\n\n  /**\n   * @param  {number} x\n   * @param  {number} y\n   * @return {module:zrender/core/PathProxy}\n   */\n  lineTo: function (x, y) {\n    var exceedUnit = mathAbs(x - this._xi) > this._ux || mathAbs(y - this._yi) > this._uy // Force draw the first segment\n    || this._len < 5;\n    this.addData(CMD.L, x, y);\n\n    if (this._ctx && exceedUnit) {\n      this._needsDash() ? this._dashedLineTo(x, y) : this._ctx.lineTo(x, y);\n    }\n\n    if (exceedUnit) {\n      this._xi = x;\n      this._yi = y;\n    }\n\n    return this;\n  },\n\n  /**\n   * @param  {number} x1\n   * @param  {number} y1\n   * @param  {number} x2\n   * @param  {number} y2\n   * @param  {number} x3\n   * @param  {number} y3\n   * @return {module:zrender/core/PathProxy}\n   */\n  bezierCurveTo: function (x1, y1, x2, y2, x3, y3) {\n    this.addData(CMD.C, x1, y1, x2, y2, x3, y3);\n\n    if (this._ctx) {\n      this._needsDash() ? this._dashedBezierTo(x1, y1, x2, y2, x3, y3) : this._ctx.bezierCurveTo(x1, y1, x2, y2, x3, y3);\n    }\n\n    this._xi = x3;\n    this._yi = y3;\n    return this;\n  },\n\n  /**\n   * @param  {number} x1\n   * @param  {number} y1\n   * @param  {number} x2\n   * @param  {number} y2\n   * @return {module:zrender/core/PathProxy}\n   */\n  quadraticCurveTo: function (x1, y1, x2, y2) {\n    this.addData(CMD.Q, x1, y1, x2, y2);\n\n    if (this._ctx) {\n      this._needsDash() ? this._dashedQuadraticTo(x1, y1, x2, y2) : this._ctx.quadraticCurveTo(x1, y1, x2, y2);\n    }\n\n    this._xi = x2;\n    this._yi = y2;\n    return this;\n  },\n\n  /**\n   * @param  {number} cx\n   * @param  {number} cy\n   * @param  {number} r\n   * @param  {number} startAngle\n   * @param  {number} endAngle\n   * @param  {boolean} anticlockwise\n   * @return {module:zrender/core/PathProxy}\n   */\n  arc: function (cx, cy, r, startAngle, endAngle, anticlockwise) {\n    this.addData(CMD.A, cx, cy, r, r, startAngle, endAngle - startAngle, 0, anticlockwise ? 0 : 1);\n    this._ctx && this._ctx.arc(cx, cy, r, startAngle, endAngle, anticlockwise);\n    this._xi = mathCos(endAngle) * r + cx;\n    this._yi = mathSin(endAngle) * r + cy;\n    return this;\n  },\n  // TODO\n  arcTo: function (x1, y1, x2, y2, radius) {\n    if (this._ctx) {\n      this._ctx.arcTo(x1, y1, x2, y2, radius);\n    }\n\n    return this;\n  },\n  // TODO\n  rect: function (x, y, w, h) {\n    this._ctx && this._ctx.rect(x, y, w, h);\n    this.addData(CMD.R, x, y, w, h);\n    return this;\n  },\n\n  /**\n   * @return {module:zrender/core/PathProxy}\n   */\n  closePath: function () {\n    this.addData(CMD.Z);\n    var ctx = this._ctx;\n    var x0 = this._x0;\n    var y0 = this._y0;\n\n    if (ctx) {\n      this._needsDash() && this._dashedLineTo(x0, y0);\n      ctx.closePath();\n    }\n\n    this._xi = x0;\n    this._yi = y0;\n    return this;\n  },\n\n  /**\n   * Context 从外部传入，因为有可能是 rebuildPath 完之后再 fill。\n   * stroke 同样\n   * @param {CanvasRenderingContext2D} ctx\n   * @return {module:zrender/core/PathProxy}\n   */\n  fill: function (ctx) {\n    ctx && ctx.fill();\n    this.toStatic();\n  },\n\n  /**\n   * @param {CanvasRenderingContext2D} ctx\n   * @return {module:zrender/core/PathProxy}\n   */\n  stroke: function (ctx) {\n    ctx && ctx.stroke();\n    this.toStatic();\n  },\n\n  /**\n   * 必须在其它绘制命令前调用\n   * Must be invoked before all other path drawing methods\n   * @return {module:zrender/core/PathProxy}\n   */\n  setLineDash: function (lineDash) {\n    if (lineDash instanceof Array) {\n      this._lineDash = lineDash;\n      this._dashIdx = 0;\n      var lineDashSum = 0;\n\n      for (var i = 0; i < lineDash.length; i++) {\n        lineDashSum += lineDash[i];\n      }\n\n      this._dashSum = lineDashSum;\n    }\n\n    return this;\n  },\n\n  /**\n   * 必须在其它绘制命令前调用\n   * Must be invoked before all other path drawing methods\n   * @return {module:zrender/core/PathProxy}\n   */\n  setLineDashOffset: function (offset) {\n    this._dashOffset = offset;\n    return this;\n  },\n\n  /**\n   *\n   * @return {boolean}\n   */\n  len: function () {\n    return this._len;\n  },\n\n  /**\n   * 直接设置 Path 数据\n   */\n  setData: function (data) {\n    var len = data.length;\n\n    if (!(this.data && this.data.length === len) && hasTypedArray) {\n      this.data = new Float32Array(len);\n    }\n\n    for (var i = 0; i < len; i++) {\n      this.data[i] = data[i];\n    }\n\n    this._len = len;\n  },\n\n  /**\n   * 添加子路径\n   * @param {module:zrender/core/PathProxy|Array.<module:zrender/core/PathProxy>} path\n   */\n  appendPath: function (path) {\n    if (!(path instanceof Array)) {\n      path = [path];\n    }\n\n    var len = path.length;\n    var appendSize = 0;\n    var offset = this._len;\n\n    for (var i = 0; i < len; i++) {\n      appendSize += path[i].len();\n    }\n\n    if (hasTypedArray && this.data instanceof Float32Array) {\n      this.data = new Float32Array(offset + appendSize);\n    }\n\n    for (var i = 0; i < len; i++) {\n      var appendPathData = path[i].data;\n\n      for (var k = 0; k < appendPathData.length; k++) {\n        this.data[offset++] = appendPathData[k];\n      }\n    }\n\n    this._len = offset;\n  },\n\n  /**\n   * 填充 Path 数据。\n   * 尽量复用而不申明新的数组。大部分图形重绘的指令数据长度都是不变的。\n   */\n  addData: function (cmd) {\n    if (!this._saveData) {\n      return;\n    }\n\n    var data = this.data;\n\n    if (this._len + arguments.length > data.length) {\n      // 因为之前的数组已经转换成静态的 Float32Array\n      // 所以不够用时需要扩展一个新的动态数组\n      this._expandData();\n\n      data = this.data;\n    }\n\n    for (var i = 0; i < arguments.length; i++) {\n      data[this._len++] = arguments[i];\n    }\n\n    this._prevCmd = cmd;\n  },\n  _expandData: function () {\n    // Only if data is Float32Array\n    if (!(this.data instanceof Array)) {\n      var newData = [];\n\n      for (var i = 0; i < this._len; i++) {\n        newData[i] = this.data[i];\n      }\n\n      this.data = newData;\n    }\n  },\n\n  /**\n   * If needs js implemented dashed line\n   * @return {boolean}\n   * @private\n   */\n  _needsDash: function () {\n    return this._lineDash;\n  },\n  _dashedLineTo: function (x1, y1) {\n    var dashSum = this._dashSum;\n    var offset = this._dashOffset;\n    var lineDash = this._lineDash;\n    var ctx = this._ctx;\n    var x0 = this._xi;\n    var y0 = this._yi;\n    var dx = x1 - x0;\n    var dy = y1 - y0;\n    var dist = mathSqrt(dx * dx + dy * dy);\n    var x = x0;\n    var y = y0;\n    var dash;\n    var nDash = lineDash.length;\n    var idx;\n    dx /= dist;\n    dy /= dist;\n\n    if (offset < 0) {\n      // Convert to positive offset\n      offset = dashSum + offset;\n    }\n\n    offset %= dashSum;\n    x -= offset * dx;\n    y -= offset * dy;\n\n    while (dx > 0 && x <= x1 || dx < 0 && x >= x1 || dx === 0 && (dy > 0 && y <= y1 || dy < 0 && y >= y1)) {\n      idx = this._dashIdx;\n      dash = lineDash[idx];\n      x += dx * dash;\n      y += dy * dash;\n      this._dashIdx = (idx + 1) % nDash; // Skip positive offset\n\n      if (dx > 0 && x < x0 || dx < 0 && x > x0 || dy > 0 && y < y0 || dy < 0 && y > y0) {\n        continue;\n      }\n\n      ctx[idx % 2 ? 'moveTo' : 'lineTo'](dx >= 0 ? mathMin(x, x1) : mathMax(x, x1), dy >= 0 ? mathMin(y, y1) : mathMax(y, y1));\n    } // Offset for next lineTo\n\n\n    dx = x - x1;\n    dy = y - y1;\n    this._dashOffset = -mathSqrt(dx * dx + dy * dy);\n  },\n  // Not accurate dashed line to\n  _dashedBezierTo: function (x1, y1, x2, y2, x3, y3) {\n    var dashSum = this._dashSum;\n    var offset = this._dashOffset;\n    var lineDash = this._lineDash;\n    var ctx = this._ctx;\n    var x0 = this._xi;\n    var y0 = this._yi;\n    var t;\n    var dx;\n    var dy;\n    var cubicAt = curve.cubicAt;\n    var bezierLen = 0;\n    var idx = this._dashIdx;\n    var nDash = lineDash.length;\n    var x;\n    var y;\n    var tmpLen = 0;\n\n    if (offset < 0) {\n      // Convert to positive offset\n      offset = dashSum + offset;\n    }\n\n    offset %= dashSum; // Bezier approx length\n\n    for (t = 0; t < 1; t += 0.1) {\n      dx = cubicAt(x0, x1, x2, x3, t + 0.1) - cubicAt(x0, x1, x2, x3, t);\n      dy = cubicAt(y0, y1, y2, y3, t + 0.1) - cubicAt(y0, y1, y2, y3, t);\n      bezierLen += mathSqrt(dx * dx + dy * dy);\n    } // Find idx after add offset\n\n\n    for (; idx < nDash; idx++) {\n      tmpLen += lineDash[idx];\n\n      if (tmpLen > offset) {\n        break;\n      }\n    }\n\n    t = (tmpLen - offset) / bezierLen;\n\n    while (t <= 1) {\n      x = cubicAt(x0, x1, x2, x3, t);\n      y = cubicAt(y0, y1, y2, y3, t); // Use line to approximate dashed bezier\n      // Bad result if dash is long\n\n      idx % 2 ? ctx.moveTo(x, y) : ctx.lineTo(x, y);\n      t += lineDash[idx] / bezierLen;\n      idx = (idx + 1) % nDash;\n    } // Finish the last segment and calculate the new offset\n\n\n    idx % 2 !== 0 && ctx.lineTo(x3, y3);\n    dx = x3 - x;\n    dy = y3 - y;\n    this._dashOffset = -mathSqrt(dx * dx + dy * dy);\n  },\n  _dashedQuadraticTo: function (x1, y1, x2, y2) {\n    // Convert quadratic to cubic using degree elevation\n    var x3 = x2;\n    var y3 = y2;\n    x2 = (x2 + 2 * x1) / 3;\n    y2 = (y2 + 2 * y1) / 3;\n    x1 = (this._xi + 2 * x1) / 3;\n    y1 = (this._yi + 2 * y1) / 3;\n\n    this._dashedBezierTo(x1, y1, x2, y2, x3, y3);\n  },\n\n  /**\n   * 转成静态的 Float32Array 减少堆内存占用\n   * Convert dynamic array to static Float32Array\n   */\n  toStatic: function () {\n    var data = this.data;\n\n    if (data instanceof Array) {\n      data.length = this._len;\n\n      if (hasTypedArray) {\n        this.data = new Float32Array(data);\n      }\n    }\n  },\n\n  /**\n   * @return {module:zrender/core/BoundingRect}\n   */\n  getBoundingRect: function () {\n    min[0] = min[1] = min2[0] = min2[1] = Number.MAX_VALUE;\n    max[0] = max[1] = max2[0] = max2[1] = -Number.MAX_VALUE;\n    var data = this.data;\n    var xi = 0;\n    var yi = 0;\n    var x0 = 0;\n    var y0 = 0;\n\n    for (var i = 0; i < data.length;) {\n      var cmd = data[i++];\n\n      if (i === 1) {\n        // 如果第一个命令是 L, C, Q\n        // 则 previous point 同绘制命令的第一个 point\n        //\n        // 第一个命令为 Arc 的情况下会在后面特殊处理\n        xi = data[i];\n        yi = data[i + 1];\n        x0 = xi;\n        y0 = yi;\n      }\n\n      switch (cmd) {\n        case CMD.M:\n          // moveTo 命令重新创建一个新的 subpath, 并且更新新的起点\n          // 在 closePath 的时候使用\n          x0 = data[i++];\n          y0 = data[i++];\n          xi = x0;\n          yi = y0;\n          min2[0] = x0;\n          min2[1] = y0;\n          max2[0] = x0;\n          max2[1] = y0;\n          break;\n\n        case CMD.L:\n          bbox.fromLine(xi, yi, data[i], data[i + 1], min2, max2);\n          xi = data[i++];\n          yi = data[i++];\n          break;\n\n        case CMD.C:\n          bbox.fromCubic(xi, yi, data[i++], data[i++], data[i++], data[i++], data[i], data[i + 1], min2, max2);\n          xi = data[i++];\n          yi = data[i++];\n          break;\n\n        case CMD.Q:\n          bbox.fromQuadratic(xi, yi, data[i++], data[i++], data[i], data[i + 1], min2, max2);\n          xi = data[i++];\n          yi = data[i++];\n          break;\n\n        case CMD.A:\n          // TODO Arc 判断的开销比较大\n          var cx = data[i++];\n          var cy = data[i++];\n          var rx = data[i++];\n          var ry = data[i++];\n          var startAngle = data[i++];\n          var endAngle = data[i++] + startAngle; // TODO Arc 旋转\n\n          i += 1;\n          var anticlockwise = 1 - data[i++];\n\n          if (i === 1) {\n            // 直接使用 arc 命令\n            // 第一个命令起点还未定义\n            x0 = mathCos(startAngle) * rx + cx;\n            y0 = mathSin(startAngle) * ry + cy;\n          }\n\n          bbox.fromArc(cx, cy, rx, ry, startAngle, endAngle, anticlockwise, min2, max2);\n          xi = mathCos(endAngle) * rx + cx;\n          yi = mathSin(endAngle) * ry + cy;\n          break;\n\n        case CMD.R:\n          x0 = xi = data[i++];\n          y0 = yi = data[i++];\n          var width = data[i++];\n          var height = data[i++]; // Use fromLine\n\n          bbox.fromLine(x0, y0, x0 + width, y0 + height, min2, max2);\n          break;\n\n        case CMD.Z:\n          xi = x0;\n          yi = y0;\n          break;\n      } // Union\n\n\n      vec2.min(min, min, min2);\n      vec2.max(max, max, max2);\n    } // No data\n\n\n    if (i === 0) {\n      min[0] = min[1] = max[0] = max[1] = 0;\n    }\n\n    return new BoundingRect(min[0], min[1], max[0] - min[0], max[1] - min[1]);\n  },\n\n  /**\n   * Rebuild path from current data\n   * Rebuild path will not consider javascript implemented line dash.\n   * @param {CanvasRenderingContext2D} ctx\n   */\n  rebuildPath: function (ctx) {\n    var d = this.data;\n    var x0, y0;\n    var xi, yi;\n    var x, y;\n    var ux = this._ux;\n    var uy = this._uy;\n    var len = this._len;\n\n    for (var i = 0; i < len;) {\n      var cmd = d[i++];\n\n      if (i === 1) {\n        // 如果第一个命令是 L, C, Q\n        // 则 previous point 同绘制命令的第一个 point\n        //\n        // 第一个命令为 Arc 的情况下会在后面特殊处理\n        xi = d[i];\n        yi = d[i + 1];\n        x0 = xi;\n        y0 = yi;\n      }\n\n      switch (cmd) {\n        case CMD.M:\n          x0 = xi = d[i++];\n          y0 = yi = d[i++];\n          ctx.moveTo(xi, yi);\n          break;\n\n        case CMD.L:\n          x = d[i++];\n          y = d[i++]; // Not draw too small seg between\n\n          if (mathAbs(x - xi) > ux || mathAbs(y - yi) > uy || i === len - 1) {\n            ctx.lineTo(x, y);\n            xi = x;\n            yi = y;\n          }\n\n          break;\n\n        case CMD.C:\n          ctx.bezierCurveTo(d[i++], d[i++], d[i++], d[i++], d[i++], d[i++]);\n          xi = d[i - 2];\n          yi = d[i - 1];\n          break;\n\n        case CMD.Q:\n          ctx.quadraticCurveTo(d[i++], d[i++], d[i++], d[i++]);\n          xi = d[i - 2];\n          yi = d[i - 1];\n          break;\n\n        case CMD.A:\n          var cx = d[i++];\n          var cy = d[i++];\n          var rx = d[i++];\n          var ry = d[i++];\n          var theta = d[i++];\n          var dTheta = d[i++];\n          var psi = d[i++];\n          var fs = d[i++];\n          var r = rx > ry ? rx : ry;\n          var scaleX = rx > ry ? 1 : rx / ry;\n          var scaleY = rx > ry ? ry / rx : 1;\n          var isEllipse = Math.abs(rx - ry) > 1e-3;\n          var endAngle = theta + dTheta;\n\n          if (isEllipse) {\n            ctx.translate(cx, cy);\n            ctx.rotate(psi);\n            ctx.scale(scaleX, scaleY);\n            ctx.arc(0, 0, r, theta, endAngle, 1 - fs);\n            ctx.scale(1 / scaleX, 1 / scaleY);\n            ctx.rotate(-psi);\n            ctx.translate(-cx, -cy);\n          } else {\n            ctx.arc(cx, cy, r, theta, endAngle, 1 - fs);\n          }\n\n          if (i === 1) {\n            // 直接使用 arc 命令\n            // 第一个命令起点还未定义\n            x0 = mathCos(theta) * rx + cx;\n            y0 = mathSin(theta) * ry + cy;\n          }\n\n          xi = mathCos(endAngle) * rx + cx;\n          yi = mathSin(endAngle) * ry + cy;\n          break;\n\n        case CMD.R:\n          x0 = xi = d[i];\n          y0 = yi = d[i + 1];\n          ctx.rect(d[i++], d[i++], d[i++], d[i++]);\n          break;\n\n        case CMD.Z:\n          ctx.closePath();\n          xi = x0;\n          yi = y0;\n      }\n    }\n  }\n};\nPathProxy.CMD = CMD;\nvar _default = PathProxy;\nmodule.exports = _default;\n\n/***/ }),\n/* 10 */\n/***/ (function(module, exports) {\n\n/**\n * 3x2矩阵操作类\n * @exports zrender/tool/matrix\n */\nvar ArrayCtor = typeof Float32Array === 'undefined' ? Array : Float32Array;\n/**\n * Create a identity matrix.\n * @return {Float32Array|Array.<number>}\n */\n\nfunction create() {\n  var out = new ArrayCtor(6);\n  identity(out);\n  return out;\n}\n/**\n * 设置矩阵为单位矩阵\n * @param {Float32Array|Array.<number>} out\n */\n\n\nfunction identity(out) {\n  out[0] = 1;\n  out[1] = 0;\n  out[2] = 0;\n  out[3] = 1;\n  out[4] = 0;\n  out[5] = 0;\n  return out;\n}\n/**\n * 复制矩阵\n * @param {Float32Array|Array.<number>} out\n * @param {Float32Array|Array.<number>} m\n */\n\n\nfunction copy(out, m) {\n  out[0] = m[0];\n  out[1] = m[1];\n  out[2] = m[2];\n  out[3] = m[3];\n  out[4] = m[4];\n  out[5] = m[5];\n  return out;\n}\n/**\n * 矩阵相乘\n * @param {Float32Array|Array.<number>} out\n * @param {Float32Array|Array.<number>} m1\n * @param {Float32Array|Array.<number>} m2\n */\n\n\nfunction mul(out, m1, m2) {\n  // Consider matrix.mul(m, m2, m);\n  // where out is the same as m2.\n  // So use temp variable to escape error.\n  var out0 = m1[0] * m2[0] + m1[2] * m2[1];\n  var out1 = m1[1] * m2[0] + m1[3] * m2[1];\n  var out2 = m1[0] * m2[2] + m1[2] * m2[3];\n  var out3 = m1[1] * m2[2] + m1[3] * m2[3];\n  var out4 = m1[0] * m2[4] + m1[2] * m2[5] + m1[4];\n  var out5 = m1[1] * m2[4] + m1[3] * m2[5] + m1[5];\n  out[0] = out0;\n  out[1] = out1;\n  out[2] = out2;\n  out[3] = out3;\n  out[4] = out4;\n  out[5] = out5;\n  return out;\n}\n/**\n * 平移变换\n * @param {Float32Array|Array.<number>} out\n * @param {Float32Array|Array.<number>} a\n * @param {Float32Array|Array.<number>} v\n */\n\n\nfunction translate(out, a, v) {\n  out[0] = a[0];\n  out[1] = a[1];\n  out[2] = a[2];\n  out[3] = a[3];\n  out[4] = a[4] + v[0];\n  out[5] = a[5] + v[1];\n  return out;\n}\n/**\n * 旋转变换\n * @param {Float32Array|Array.<number>} out\n * @param {Float32Array|Array.<number>} a\n * @param {number} rad\n */\n\n\nfunction rotate(out, a, rad) {\n  var aa = a[0];\n  var ac = a[2];\n  var atx = a[4];\n  var ab = a[1];\n  var ad = a[3];\n  var aty = a[5];\n  var st = Math.sin(rad);\n  var ct = Math.cos(rad);\n  out[0] = aa * ct + ab * st;\n  out[1] = -aa * st + ab * ct;\n  out[2] = ac * ct + ad * st;\n  out[3] = -ac * st + ct * ad;\n  out[4] = ct * atx + st * aty;\n  out[5] = ct * aty - st * atx;\n  return out;\n}\n/**\n * 缩放变换\n * @param {Float32Array|Array.<number>} out\n * @param {Float32Array|Array.<number>} a\n * @param {Float32Array|Array.<number>} v\n */\n\n\nfunction scale(out, a, v) {\n  var vx = v[0];\n  var vy = v[1];\n  out[0] = a[0] * vx;\n  out[1] = a[1] * vy;\n  out[2] = a[2] * vx;\n  out[3] = a[3] * vy;\n  out[4] = a[4] * vx;\n  out[5] = a[5] * vy;\n  return out;\n}\n/**\n * 求逆矩阵\n * @param {Float32Array|Array.<number>} out\n * @param {Float32Array|Array.<number>} a\n */\n\n\nfunction invert(out, a) {\n  var aa = a[0];\n  var ac = a[2];\n  var atx = a[4];\n  var ab = a[1];\n  var ad = a[3];\n  var aty = a[5];\n  var det = aa * ad - ab * ac;\n\n  if (!det) {\n    return null;\n  }\n\n  det = 1.0 / det;\n  out[0] = ad * det;\n  out[1] = -ab * det;\n  out[2] = -ac * det;\n  out[3] = aa * det;\n  out[4] = (ac * aty - ad * atx) * det;\n  out[5] = (ab * atx - aa * aty) * det;\n  return out;\n}\n/**\n * Clone a new matrix.\n * @param {Float32Array|Array.<number>} a\n */\n\n\nfunction clone(a) {\n  var b = create();\n  copy(b, a);\n  return b;\n}\n\nexports.create = create;\nexports.identity = identity;\nexports.copy = copy;\nexports.mul = mul;\nexports.translate = translate;\nexports.rotate = rotate;\nexports.scale = scale;\nexports.invert = invert;\nexports.clone = clone;\n\n/***/ }),\n/* 11 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar LRU = __webpack_require__(20);\n\nvar globalImageCache = new LRU(50);\n/**\n * @param {string|HTMLImageElement|HTMLCanvasElement|Canvas} newImageOrSrc\n * @return {HTMLImageElement|HTMLCanvasElement|Canvas} image\n */\n\nfunction findExistImage(newImageOrSrc) {\n  if (typeof newImageOrSrc === 'string') {\n    var cachedImgObj = globalImageCache.get(newImageOrSrc);\n    return cachedImgObj && cachedImgObj.image;\n  } else {\n    return newImageOrSrc;\n  }\n}\n/**\n * Caution: User should cache loaded images, but not just count on LRU.\n * Consider if required images more than LRU size, will dead loop occur?\n *\n * @param {string|HTMLImageElement|HTMLCanvasElement|Canvas} newImageOrSrc\n * @param {HTMLImageElement|HTMLCanvasElement|Canvas} image Existent image.\n * @param {module:zrender/Element} [hostEl] For calling `dirty`.\n * @param {Function} [cb] params: (image, cbPayload)\n * @param {Object} [cbPayload] Payload on cb calling.\n * @return {HTMLImageElement|HTMLCanvasElement|Canvas} image\n */\n\n\nfunction createOrUpdateImage(newImageOrSrc, image, hostEl, cb, cbPayload) {\n  if (!newImageOrSrc) {\n    return image;\n  } else if (typeof newImageOrSrc === 'string') {\n    // Image should not be loaded repeatly.\n    if (image && image.__zrImageSrc === newImageOrSrc || !hostEl) {\n      return image;\n    } // Only when there is no existent image or existent image src\n    // is different, this method is responsible for load.\n\n\n    var cachedImgObj = globalImageCache.get(newImageOrSrc);\n    var pendingWrap = {\n      hostEl: hostEl,\n      cb: cb,\n      cbPayload: cbPayload\n    };\n\n    if (cachedImgObj) {\n      image = cachedImgObj.image;\n      !isImageReady(image) && cachedImgObj.pending.push(pendingWrap);\n    } else {\n      image = new Image();\n      image.onload = image.onerror = imageOnLoad;\n      globalImageCache.put(newImageOrSrc, image.__cachedImgObj = {\n        image: image,\n        pending: [pendingWrap]\n      });\n      image.src = image.__zrImageSrc = newImageOrSrc;\n    }\n\n    return image;\n  } // newImageOrSrc is an HTMLImageElement or HTMLCanvasElement or Canvas\n  else {\n      return newImageOrSrc;\n    }\n}\n\nfunction imageOnLoad() {\n  var cachedImgObj = this.__cachedImgObj;\n  this.onload = this.onerror = this.__cachedImgObj = null;\n\n  for (var i = 0; i < cachedImgObj.pending.length; i++) {\n    var pendingWrap = cachedImgObj.pending[i];\n    var cb = pendingWrap.cb;\n    cb && cb(this, pendingWrap.cbPayload);\n    pendingWrap.hostEl.dirty();\n  }\n\n  cachedImgObj.pending.length = 0;\n}\n\nfunction isImageReady(image) {\n  return image && image.width && image.height;\n}\n\nexports.findExistImage = findExistImage;\nexports.createOrUpdateImage = createOrUpdateImage;\nexports.isImageReady = isImageReady;\n\n/***/ }),\n/* 12 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar zrUtil = __webpack_require__(0);\n\nvar env = __webpack_require__(13);\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\nvar each = zrUtil.each;\nvar isObject = zrUtil.isObject;\nvar isArray = zrUtil.isArray;\n/**\n * Make the name displayable. But we should\n * make sure it is not duplicated with user\n * specified name, so use '\\0';\n */\n\nvar DUMMY_COMPONENT_NAME_PREFIX = 'series\\0';\n/**\n * If value is not array, then translate it to array.\n * @param  {*} value\n * @return {Array} [value] or value\n */\n\nfunction normalizeToArray(value) {\n  return value instanceof Array ? value : value == null ? [] : [value];\n}\n/**\n * Sync default option between normal and emphasis like `position` and `show`\n * In case some one will write code like\n *     label: {\n *          show: false,\n *          position: 'outside',\n *          fontSize: 18\n *     },\n *     emphasis: {\n *          label: { show: true }\n *     }\n * @param {Object} opt\n * @param {string} key\n * @param {Array.<string>} subOpts\n */\n\n\nfunction defaultEmphasis(opt, key, subOpts) {\n  // Caution: performance sensitive.\n  if (opt) {\n    opt[key] = opt[key] || {};\n    opt.emphasis = opt.emphasis || {};\n    opt.emphasis[key] = opt.emphasis[key] || {}; // Default emphasis option from normal\n\n    for (var i = 0, len = subOpts.length; i < len; i++) {\n      var subOptName = subOpts[i];\n\n      if (!opt.emphasis[key].hasOwnProperty(subOptName) && opt[key].hasOwnProperty(subOptName)) {\n        opt.emphasis[key][subOptName] = opt[key][subOptName];\n      }\n    }\n  }\n}\n\nvar TEXT_STYLE_OPTIONS = ['fontStyle', 'fontWeight', 'fontSize', 'fontFamily', 'rich', 'tag', 'color', 'textBorderColor', 'textBorderWidth', 'width', 'height', 'lineHeight', 'align', 'verticalAlign', 'baseline', 'shadowColor', 'shadowBlur', 'shadowOffsetX', 'shadowOffsetY', 'textShadowColor', 'textShadowBlur', 'textShadowOffsetX', 'textShadowOffsetY', 'backgroundColor', 'borderColor', 'borderWidth', 'borderRadius', 'padding']; // modelUtil.LABEL_OPTIONS = modelUtil.TEXT_STYLE_OPTIONS.concat([\n//     'position', 'offset', 'rotate', 'origin', 'show', 'distance', 'formatter',\n//     'fontStyle', 'fontWeight', 'fontSize', 'fontFamily',\n//     // FIXME: deprecated, check and remove it.\n//     'textStyle'\n// ]);\n\n/**\n * The method do not ensure performance.\n * data could be [12, 2323, {value: 223}, [1221, 23], {value: [2, 23]}]\n * This helper method retieves value from data.\n * @param {string|number|Date|Array|Object} dataItem\n * @return {number|string|Date|Array.<number|string|Date>}\n */\n\nfunction getDataItemValue(dataItem) {\n  return isObject(dataItem) && !isArray(dataItem) && !(dataItem instanceof Date) ? dataItem.value : dataItem;\n}\n/**\n * data could be [12, 2323, {value: 223}, [1221, 23], {value: [2, 23]}]\n * This helper method determine if dataItem has extra option besides value\n * @param {string|number|Date|Array|Object} dataItem\n */\n\n\nfunction isDataItemOption(dataItem) {\n  return isObject(dataItem) && !(dataItem instanceof Array); // // markLine data can be array\n  // && !(dataItem[0] && isObject(dataItem[0]) && !(dataItem[0] instanceof Array));\n}\n/**\n * Mapping to exists for merge.\n *\n * @public\n * @param {Array.<Object>|Array.<module:echarts/model/Component>} exists\n * @param {Object|Array.<Object>} newCptOptions\n * @return {Array.<Object>} Result, like [{exist: ..., option: ...}, {}],\n *                          index of which is the same as exists.\n */\n\n\nfunction mappingToExists(exists, newCptOptions) {\n  // Mapping by the order by original option (but not order of\n  // new option) in merge mode. Because we should ensure\n  // some specified index (like xAxisIndex) is consistent with\n  // original option, which is easy to understand, espatially in\n  // media query. And in most case, merge option is used to\n  // update partial option but not be expected to change order.\n  newCptOptions = (newCptOptions || []).slice();\n  var result = zrUtil.map(exists || [], function (obj, index) {\n    return {\n      exist: obj\n    };\n  }); // Mapping by id or name if specified.\n\n  each(newCptOptions, function (cptOption, index) {\n    if (!isObject(cptOption)) {\n      return;\n    } // id has highest priority.\n\n\n    for (var i = 0; i < result.length; i++) {\n      if (!result[i].option // Consider name: two map to one.\n      && cptOption.id != null && result[i].exist.id === cptOption.id + '') {\n        result[i].option = cptOption;\n        newCptOptions[index] = null;\n        return;\n      }\n    }\n\n    for (var i = 0; i < result.length; i++) {\n      var exist = result[i].exist;\n\n      if (!result[i].option // Consider name: two map to one.\n      // Can not match when both ids exist but different.\n      && (exist.id == null || cptOption.id == null) && cptOption.name != null && !isIdInner(cptOption) && !isIdInner(exist) && exist.name === cptOption.name + '') {\n        result[i].option = cptOption;\n        newCptOptions[index] = null;\n        return;\n      }\n    }\n  }); // Otherwise mapping by index.\n\n  each(newCptOptions, function (cptOption, index) {\n    if (!isObject(cptOption)) {\n      return;\n    }\n\n    var i = 0;\n\n    for (; i < result.length; i++) {\n      var exist = result[i].exist;\n\n      if (!result[i].option // Existing model that already has id should be able to\n      // mapped to (because after mapping performed model may\n      // be assigned with a id, whish should not affect next\n      // mapping), except those has inner id.\n      && !isIdInner(exist) // Caution:\n      // Do not overwrite id. But name can be overwritten,\n      // because axis use name as 'show label text'.\n      // 'exist' always has id and name and we dont\n      // need to check it.\n      && cptOption.id == null) {\n        result[i].option = cptOption;\n        break;\n      }\n    }\n\n    if (i >= result.length) {\n      result.push({\n        option: cptOption\n      });\n    }\n  });\n  return result;\n}\n/**\n * Make id and name for mapping result (result of mappingToExists)\n * into `keyInfo` field.\n *\n * @public\n * @param {Array.<Object>} Result, like [{exist: ..., option: ...}, {}],\n *                          which order is the same as exists.\n * @return {Array.<Object>} The input.\n */\n\n\nfunction makeIdAndName(mapResult) {\n  // We use this id to hash component models and view instances\n  // in echarts. id can be specified by user, or auto generated.\n  // The id generation rule ensures new view instance are able\n  // to mapped to old instance when setOption are called in\n  // no-merge mode. So we generate model id by name and plus\n  // type in view id.\n  // name can be duplicated among components, which is convenient\n  // to specify multi components (like series) by one name.\n  // Ensure that each id is distinct.\n  var idMap = zrUtil.createHashMap();\n  each(mapResult, function (item, index) {\n    var existCpt = item.exist;\n    existCpt && idMap.set(existCpt.id, item);\n  });\n  each(mapResult, function (item, index) {\n    var opt = item.option;\n    zrUtil.assert(!opt || opt.id == null || !idMap.get(opt.id) || idMap.get(opt.id) === item, 'id duplicates: ' + (opt && opt.id));\n    opt && opt.id != null && idMap.set(opt.id, item);\n    !item.keyInfo && (item.keyInfo = {});\n  }); // Make name and id.\n\n  each(mapResult, function (item, index) {\n    var existCpt = item.exist;\n    var opt = item.option;\n    var keyInfo = item.keyInfo;\n\n    if (!isObject(opt)) {\n      return;\n    } // name can be overwitten. Consider case: axis.name = '20km'.\n    // But id generated by name will not be changed, which affect\n    // only in that case: setOption with 'not merge mode' and view\n    // instance will be recreated, which can be accepted.\n\n\n    keyInfo.name = opt.name != null ? opt.name + '' : existCpt ? existCpt.name // Avoid diffferent series has the same name,\n    // because name may be used like in color pallet.\n    : DUMMY_COMPONENT_NAME_PREFIX + index;\n\n    if (existCpt) {\n      keyInfo.id = existCpt.id;\n    } else if (opt.id != null) {\n      keyInfo.id = opt.id + '';\n    } else {\n      // Consider this situatoin:\n      //  optionA: [{name: 'a'}, {name: 'a'}, {..}]\n      //  optionB [{..}, {name: 'a'}, {name: 'a'}]\n      // Series with the same name between optionA and optionB\n      // should be mapped.\n      var idNum = 0;\n\n      do {\n        keyInfo.id = '\\0' + keyInfo.name + '\\0' + idNum++;\n      } while (idMap.get(keyInfo.id));\n    }\n\n    idMap.set(keyInfo.id, item);\n  });\n}\n\nfunction isNameSpecified(componentModel) {\n  var name = componentModel.name; // Is specified when `indexOf` get -1 or > 0.\n\n  return !!(name && name.indexOf(DUMMY_COMPONENT_NAME_PREFIX));\n}\n/**\n * @public\n * @param {Object} cptOption\n * @return {boolean}\n */\n\n\nfunction isIdInner(cptOption) {\n  return isObject(cptOption) && cptOption.id && (cptOption.id + '').indexOf('\\0_ec_\\0') === 0;\n}\n/**\n * A helper for removing duplicate items between batchA and batchB,\n * and in themselves, and categorize by series.\n *\n * @param {Array.<Object>} batchA Like: [{seriesId: 2, dataIndex: [32, 4, 5]}, ...]\n * @param {Array.<Object>} batchB Like: [{seriesId: 2, dataIndex: [32, 4, 5]}, ...]\n * @return {Array.<Array.<Object>, Array.<Object>>} result: [resultBatchA, resultBatchB]\n */\n\n\nfunction compressBatches(batchA, batchB) {\n  var mapA = {};\n  var mapB = {};\n  makeMap(batchA || [], mapA);\n  makeMap(batchB || [], mapB, mapA);\n  return [mapToArray(mapA), mapToArray(mapB)];\n\n  function makeMap(sourceBatch, map, otherMap) {\n    for (var i = 0, len = sourceBatch.length; i < len; i++) {\n      var seriesId = sourceBatch[i].seriesId;\n      var dataIndices = normalizeToArray(sourceBatch[i].dataIndex);\n      var otherDataIndices = otherMap && otherMap[seriesId];\n\n      for (var j = 0, lenj = dataIndices.length; j < lenj; j++) {\n        var dataIndex = dataIndices[j];\n\n        if (otherDataIndices && otherDataIndices[dataIndex]) {\n          otherDataIndices[dataIndex] = null;\n        } else {\n          (map[seriesId] || (map[seriesId] = {}))[dataIndex] = 1;\n        }\n      }\n    }\n  }\n\n  function mapToArray(map, isData) {\n    var result = [];\n\n    for (var i in map) {\n      if (map.hasOwnProperty(i) && map[i] != null) {\n        if (isData) {\n          result.push(+i);\n        } else {\n          var dataIndices = mapToArray(map[i], true);\n          dataIndices.length && result.push({\n            seriesId: i,\n            dataIndex: dataIndices\n          });\n        }\n      }\n    }\n\n    return result;\n  }\n}\n/**\n * @param {module:echarts/data/List} data\n * @param {Object} payload Contains dataIndex (means rawIndex) / dataIndexInside / name\n *                         each of which can be Array or primary type.\n * @return {number|Array.<number>} dataIndex If not found, return undefined/null.\n */\n\n\nfunction queryDataIndex(data, payload) {\n  if (payload.dataIndexInside != null) {\n    return payload.dataIndexInside;\n  } else if (payload.dataIndex != null) {\n    return zrUtil.isArray(payload.dataIndex) ? zrUtil.map(payload.dataIndex, function (value) {\n      return data.indexOfRawIndex(value);\n    }) : data.indexOfRawIndex(payload.dataIndex);\n  } else if (payload.name != null) {\n    return zrUtil.isArray(payload.name) ? zrUtil.map(payload.name, function (value) {\n      return data.indexOfName(value);\n    }) : data.indexOfName(payload.name);\n  }\n}\n/**\n * Enable property storage to any host object.\n * Notice: Serialization is not supported.\n *\n * For example:\n * var inner = zrUitl.makeInner();\n *\n * function some1(hostObj) {\n *      inner(hostObj).someProperty = 1212;\n *      ...\n * }\n * function some2() {\n *      var fields = inner(this);\n *      fields.someProperty1 = 1212;\n *      fields.someProperty2 = 'xx';\n *      ...\n * }\n *\n * @return {Function}\n */\n\n\nfunction makeInner() {\n  // Consider different scope by es module import.\n  var key = '__\\0ec_inner_' + innerUniqueIndex++ + '_' + Math.random().toFixed(5);\n  return function (hostObj) {\n    return hostObj[key] || (hostObj[key] = {});\n  };\n}\n\nvar innerUniqueIndex = 0;\n/**\n * @param {module:echarts/model/Global} ecModel\n * @param {string|Object} finder\n *        If string, e.g., 'geo', means {geoIndex: 0}.\n *        If Object, could contain some of these properties below:\n *        {\n *            seriesIndex, seriesId, seriesName,\n *            geoIndex, geoId, geoName,\n *            bmapIndex, bmapId, bmapName,\n *            xAxisIndex, xAxisId, xAxisName,\n *            yAxisIndex, yAxisId, yAxisName,\n *            gridIndex, gridId, gridName,\n *            ... (can be extended)\n *        }\n *        Each properties can be number|string|Array.<number>|Array.<string>\n *        For example, a finder could be\n *        {\n *            seriesIndex: 3,\n *            geoId: ['aa', 'cc'],\n *            gridName: ['xx', 'rr']\n *        }\n *        xxxIndex can be set as 'all' (means all xxx) or 'none' (means not specify)\n *        If nothing or null/undefined specified, return nothing.\n * @param {Object} [opt]\n * @param {string} [opt.defaultMainType]\n * @param {Array.<string>} [opt.includeMainTypes]\n * @return {Object} result like:\n *        {\n *            seriesModels: [seriesModel1, seriesModel2],\n *            seriesModel: seriesModel1, // The first model\n *            geoModels: [geoModel1, geoModel2],\n *            geoModel: geoModel1, // The first model\n *            ...\n *        }\n */\n\nfunction parseFinder(ecModel, finder, opt) {\n  if (zrUtil.isString(finder)) {\n    var obj = {};\n    obj[finder + 'Index'] = 0;\n    finder = obj;\n  }\n\n  var defaultMainType = opt && opt.defaultMainType;\n\n  if (defaultMainType && !has(finder, defaultMainType + 'Index') && !has(finder, defaultMainType + 'Id') && !has(finder, defaultMainType + 'Name')) {\n    finder[defaultMainType + 'Index'] = 0;\n  }\n\n  var result = {};\n  each(finder, function (value, key) {\n    var value = finder[key]; // Exclude 'dataIndex' and other illgal keys.\n\n    if (key === 'dataIndex' || key === 'dataIndexInside') {\n      result[key] = value;\n      return;\n    }\n\n    var parsedKey = key.match(/^(\\w+)(Index|Id|Name)$/) || [];\n    var mainType = parsedKey[1];\n    var queryType = (parsedKey[2] || '').toLowerCase();\n\n    if (!mainType || !queryType || value == null || queryType === 'index' && value === 'none' || opt && opt.includeMainTypes && zrUtil.indexOf(opt.includeMainTypes, mainType) < 0) {\n      return;\n    }\n\n    var queryParam = {\n      mainType: mainType\n    };\n\n    if (queryType !== 'index' || value !== 'all') {\n      queryParam[queryType] = value;\n    }\n\n    var models = ecModel.queryComponents(queryParam);\n    result[mainType + 'Models'] = models;\n    result[mainType + 'Model'] = models[0];\n  });\n  return result;\n}\n\nfunction has(obj, prop) {\n  return obj && obj.hasOwnProperty(prop);\n}\n\nfunction setAttribute(dom, key, value) {\n  dom.setAttribute ? dom.setAttribute(key, value) : dom[key] = value;\n}\n\nfunction getAttribute(dom, key) {\n  return dom.getAttribute ? dom.getAttribute(key) : dom[key];\n}\n\nfunction getTooltipRenderMode(renderModeOption) {\n  if (renderModeOption === 'auto') {\n    // Using html when `document` exists, use richText otherwise\n    return env.domSupported ? 'html' : 'richText';\n  } else {\n    return renderModeOption || 'html';\n  }\n}\n/**\n * Group a list by key.\n *\n * @param {Array} array\n * @param {Function} getKey\n *        param {*} Array item\n *        return {string} key\n * @return {Object} Result\n *        {Array}: keys,\n *        {module:zrender/core/util/HashMap} buckets: {key -> Array}\n */\n\n\nfunction groupData(array, getKey) {\n  var buckets = zrUtil.createHashMap();\n  var keys = [];\n  zrUtil.each(array, function (item) {\n    var key = getKey(item);\n    (buckets.get(key) || (keys.push(key), buckets.set(key, []))).push(item);\n  });\n  return {\n    keys: keys,\n    buckets: buckets\n  };\n}\n\nexports.normalizeToArray = normalizeToArray;\nexports.defaultEmphasis = defaultEmphasis;\nexports.TEXT_STYLE_OPTIONS = TEXT_STYLE_OPTIONS;\nexports.getDataItemValue = getDataItemValue;\nexports.isDataItemOption = isDataItemOption;\nexports.mappingToExists = mappingToExists;\nexports.makeIdAndName = makeIdAndName;\nexports.isNameSpecified = isNameSpecified;\nexports.isIdInner = isIdInner;\nexports.compressBatches = compressBatches;\nexports.queryDataIndex = queryDataIndex;\nexports.makeInner = makeInner;\nexports.parseFinder = parseFinder;\nexports.setAttribute = setAttribute;\nexports.getAttribute = getAttribute;\nexports.getTooltipRenderMode = getTooltipRenderMode;\nexports.groupData = groupData;\n\n/***/ }),\n/* 13 */\n/***/ (function(module, exports) {\n\n/**\n * echarts设备环境识别\n *\n * @desc echarts基于Canvas，纯Javascript图表库，提供直观，生动，可交互，可个性化定制的数据统计图表。\n * @author firede[firede@firede.us]\n * @desc thanks zepto.\n */\nvar env = {};\n\nif (typeof wx === 'object' && typeof wx.getSystemInfoSync === 'function') {\n  // In Weixin Application\n  env = {\n    browser: {},\n    os: {},\n    node: false,\n    wxa: true,\n    // Weixin Application\n    canvasSupported: true,\n    svgSupported: false,\n    touchEventsSupported: true,\n    domSupported: false\n  };\n} else if (typeof document === 'undefined' && typeof self !== 'undefined') {\n  // In worker\n  env = {\n    browser: {},\n    os: {},\n    node: false,\n    worker: true,\n    canvasSupported: true,\n    domSupported: false\n  };\n} else if (typeof navigator === 'undefined') {\n  // In node\n  env = {\n    browser: {},\n    os: {},\n    node: true,\n    worker: false,\n    // Assume canvas is supported\n    canvasSupported: true,\n    svgSupported: true,\n    domSupported: false\n  };\n} else {\n  env = detect(navigator.userAgent);\n}\n\nvar _default = env; // Zepto.js\n// (c) 2010-2013 Thomas Fuchs\n// Zepto.js may be freely distributed under the MIT license.\n\nfunction detect(ua) {\n  var os = {};\n  var browser = {}; // var webkit = ua.match(/Web[kK]it[\\/]{0,1}([\\d.]+)/);\n  // var android = ua.match(/(Android);?[\\s\\/]+([\\d.]+)?/);\n  // var ipad = ua.match(/(iPad).*OS\\s([\\d_]+)/);\n  // var ipod = ua.match(/(iPod)(.*OS\\s([\\d_]+))?/);\n  // var iphone = !ipad && ua.match(/(iPhone\\sOS)\\s([\\d_]+)/);\n  // var webos = ua.match(/(webOS|hpwOS)[\\s\\/]([\\d.]+)/);\n  // var touchpad = webos && ua.match(/TouchPad/);\n  // var kindle = ua.match(/Kindle\\/([\\d.]+)/);\n  // var silk = ua.match(/Silk\\/([\\d._]+)/);\n  // var blackberry = ua.match(/(BlackBerry).*Version\\/([\\d.]+)/);\n  // var bb10 = ua.match(/(BB10).*Version\\/([\\d.]+)/);\n  // var rimtabletos = ua.match(/(RIM\\sTablet\\sOS)\\s([\\d.]+)/);\n  // var playbook = ua.match(/PlayBook/);\n  // var chrome = ua.match(/Chrome\\/([\\d.]+)/) || ua.match(/CriOS\\/([\\d.]+)/);\n\n  var firefox = ua.match(/Firefox\\/([\\d.]+)/); // var safari = webkit && ua.match(/Mobile\\//) && !chrome;\n  // var webview = ua.match(/(iPhone|iPod|iPad).*AppleWebKit(?!.*Safari)/) && !chrome;\n\n  var ie = ua.match(/MSIE\\s([\\d.]+)/) // IE 11 Trident/7.0; rv:11.0\n  || ua.match(/Trident\\/.+?rv:(([\\d.]+))/);\n  var edge = ua.match(/Edge\\/([\\d.]+)/); // IE 12 and 12+\n\n  var weChat = /micromessenger/i.test(ua); // Todo: clean this up with a better OS/browser seperation:\n  // - discern (more) between multiple browsers on android\n  // - decide if kindle fire in silk mode is android or not\n  // - Firefox on Android doesn't specify the Android version\n  // - possibly devide in os, device and browser hashes\n  // if (browser.webkit = !!webkit) browser.version = webkit[1];\n  // if (android) os.android = true, os.version = android[2];\n  // if (iphone && !ipod) os.ios = os.iphone = true, os.version = iphone[2].replace(/_/g, '.');\n  // if (ipad) os.ios = os.ipad = true, os.version = ipad[2].replace(/_/g, '.');\n  // if (ipod) os.ios = os.ipod = true, os.version = ipod[3] ? ipod[3].replace(/_/g, '.') : null;\n  // if (webos) os.webos = true, os.version = webos[2];\n  // if (touchpad) os.touchpad = true;\n  // if (blackberry) os.blackberry = true, os.version = blackberry[2];\n  // if (bb10) os.bb10 = true, os.version = bb10[2];\n  // if (rimtabletos) os.rimtabletos = true, os.version = rimtabletos[2];\n  // if (playbook) browser.playbook = true;\n  // if (kindle) os.kindle = true, os.version = kindle[1];\n  // if (silk) browser.silk = true, browser.version = silk[1];\n  // if (!silk && os.android && ua.match(/Kindle Fire/)) browser.silk = true;\n  // if (chrome) browser.chrome = true, browser.version = chrome[1];\n\n  if (firefox) {\n    browser.firefox = true;\n    browser.version = firefox[1];\n  } // if (safari && (ua.match(/Safari/) || !!os.ios)) browser.safari = true;\n  // if (webview) browser.webview = true;\n\n\n  if (ie) {\n    browser.ie = true;\n    browser.version = ie[1];\n  }\n\n  if (edge) {\n    browser.edge = true;\n    browser.version = edge[1];\n  } // It is difficult to detect WeChat in Win Phone precisely, because ua can\n  // not be set on win phone. So we do not consider Win Phone.\n\n\n  if (weChat) {\n    browser.weChat = true;\n  } // os.tablet = !!(ipad || playbook || (android && !ua.match(/Mobile/)) ||\n  //     (firefox && ua.match(/Tablet/)) || (ie && !ua.match(/Phone/) && ua.match(/Touch/)));\n  // os.phone  = !!(!os.tablet && !os.ipod && (android || iphone || webos ||\n  //     (chrome && ua.match(/Android/)) || (chrome && ua.match(/CriOS\\/([\\d.]+)/)) ||\n  //     (firefox && ua.match(/Mobile/)) || (ie && ua.match(/Touch/))));\n\n\n  return {\n    browser: browser,\n    os: os,\n    node: false,\n    // 原生canvas支持，改极端点了\n    // canvasSupported : !(browser.ie && parseFloat(browser.version) < 9)\n    canvasSupported: !!document.createElement('canvas').getContext,\n    svgSupported: typeof SVGRect !== 'undefined',\n    // works on most browsers\n    // IE10/11 does not support touch event, and MS Edge supports them but not by\n    // default, so we dont check navigator.maxTouchPoints for them here.\n    touchEventsSupported: 'ontouchstart' in window && !browser.ie && !browser.edge,\n    // <http://caniuse.com/#search=pointer%20event>.\n    pointerEventsSupported: 'onpointerdown' in window // Firefox supports pointer but not by default, only MS browsers are reliable on pointer\n    // events currently. So we dont use that on other browsers unless tested sufficiently.\n    // Although IE 10 supports pointer event, it use old style and is different from the\n    // standard. So we exclude that. (IE 10 is hardly used on touch device)\n    && (browser.edge || browser.ie && browser.version >= 11),\n    // passiveSupported: detectPassiveSupport()\n    domSupported: typeof document !== 'undefined'\n  };\n} // See https://github.com/WICG/EventListenerOptions/blob/gh-pages/explainer.md#feature-detection\n// function detectPassiveSupport() {\n//     // Test via a getter in the options object to see if the passive property is accessed\n//     var supportsPassive = false;\n//     try {\n//         var opts = Object.defineProperty({}, 'passive', {\n//             get: function() {\n//                 supportsPassive = true;\n//             }\n//         });\n//         window.addEventListener('testPassive', function() {}, opts);\n//     } catch (e) {\n//     }\n//     return supportsPassive;\n// }\n\n\nmodule.exports = _default;\n\n/***/ }),\n/* 14 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar _util = __webpack_require__(0);\n\nvar createHashMap = _util.createHashMap;\nvar isTypedArray = _util.isTypedArray;\n\nvar _clazz = __webpack_require__(36);\n\nvar enableClassCheck = _clazz.enableClassCheck;\n\nvar _sourceType = __webpack_require__(15);\n\nvar SOURCE_FORMAT_ORIGINAL = _sourceType.SOURCE_FORMAT_ORIGINAL;\nvar SERIES_LAYOUT_BY_COLUMN = _sourceType.SERIES_LAYOUT_BY_COLUMN;\nvar SOURCE_FORMAT_UNKNOWN = _sourceType.SOURCE_FORMAT_UNKNOWN;\nvar SOURCE_FORMAT_TYPED_ARRAY = _sourceType.SOURCE_FORMAT_TYPED_ARRAY;\nvar SOURCE_FORMAT_KEYED_COLUMNS = _sourceType.SOURCE_FORMAT_KEYED_COLUMNS;\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n/**\n * [sourceFormat]\n *\n * + \"original\":\n * This format is only used in series.data, where\n * itemStyle can be specified in data item.\n *\n * + \"arrayRows\":\n * [\n *     ['product', 'score', 'amount'],\n *     ['Matcha Latte', 89.3, 95.8],\n *     ['Milk Tea', 92.1, 89.4],\n *     ['Cheese Cocoa', 94.4, 91.2],\n *     ['Walnut Brownie', 85.4, 76.9]\n * ]\n *\n * + \"objectRows\":\n * [\n *     {product: 'Matcha Latte', score: 89.3, amount: 95.8},\n *     {product: 'Milk Tea', score: 92.1, amount: 89.4},\n *     {product: 'Cheese Cocoa', score: 94.4, amount: 91.2},\n *     {product: 'Walnut Brownie', score: 85.4, amount: 76.9}\n * ]\n *\n * + \"keyedColumns\":\n * {\n *     'product': ['Matcha Latte', 'Milk Tea', 'Cheese Cocoa', 'Walnut Brownie'],\n *     'count': [823, 235, 1042, 988],\n *     'score': [95.8, 81.4, 91.2, 76.9]\n * }\n *\n * + \"typedArray\"\n *\n * + \"unknown\"\n */\n\n/**\n * @constructor\n * @param {Object} fields\n * @param {string} fields.sourceFormat\n * @param {Array|Object} fields.fromDataset\n * @param {Array|Object} [fields.data]\n * @param {string} [seriesLayoutBy='column']\n * @param {Array.<Object|string>} [dimensionsDefine]\n * @param {Objet|HashMap} [encodeDefine]\n * @param {number} [startIndex=0]\n * @param {number} [dimensionsDetectCount]\n */\nfunction Source(fields) {\n  /**\n   * @type {boolean}\n   */\n  this.fromDataset = fields.fromDataset;\n  /**\n   * Not null/undefined.\n   * @type {Array|Object}\n   */\n\n  this.data = fields.data || (fields.sourceFormat === SOURCE_FORMAT_KEYED_COLUMNS ? {} : []);\n  /**\n   * See also \"detectSourceFormat\".\n   * Not null/undefined.\n   * @type {string}\n   */\n\n  this.sourceFormat = fields.sourceFormat || SOURCE_FORMAT_UNKNOWN;\n  /**\n   * 'row' or 'column'\n   * Not null/undefined.\n   * @type {string} seriesLayoutBy\n   */\n\n  this.seriesLayoutBy = fields.seriesLayoutBy || SERIES_LAYOUT_BY_COLUMN;\n  /**\n   * dimensions definition in option.\n   * can be null/undefined.\n   * @type {Array.<Object|string>}\n   */\n\n  this.dimensionsDefine = fields.dimensionsDefine;\n  /**\n   * encode definition in option.\n   * can be null/undefined.\n   * @type {Objet|HashMap}\n   */\n\n  this.encodeDefine = fields.encodeDefine && createHashMap(fields.encodeDefine);\n  /**\n   * Not null/undefined, uint.\n   * @type {number}\n   */\n\n  this.startIndex = fields.startIndex || 0;\n  /**\n   * Can be null/undefined (when unknown), uint.\n   * @type {number}\n   */\n\n  this.dimensionsDetectCount = fields.dimensionsDetectCount;\n}\n/**\n * Wrap original series data for some compatibility cases.\n */\n\n\nSource.seriesDataToSource = function (data) {\n  return new Source({\n    data: data,\n    sourceFormat: isTypedArray(data) ? SOURCE_FORMAT_TYPED_ARRAY : SOURCE_FORMAT_ORIGINAL,\n    fromDataset: false\n  });\n};\n\nenableClassCheck(Source);\nvar _default = Source;\nmodule.exports = _default;\n\n/***/ }),\n/* 15 */\n/***/ (function(module, exports) {\n\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n// Avoid typo.\nvar SOURCE_FORMAT_ORIGINAL = 'original';\nvar SOURCE_FORMAT_ARRAY_ROWS = 'arrayRows';\nvar SOURCE_FORMAT_OBJECT_ROWS = 'objectRows';\nvar SOURCE_FORMAT_KEYED_COLUMNS = 'keyedColumns';\nvar SOURCE_FORMAT_UNKNOWN = 'unknown'; // ??? CHANGE A NAME\n\nvar SOURCE_FORMAT_TYPED_ARRAY = 'typedArray';\nvar SERIES_LAYOUT_BY_COLUMN = 'column';\nvar SERIES_LAYOUT_BY_ROW = 'row';\nexports.SOURCE_FORMAT_ORIGINAL = SOURCE_FORMAT_ORIGINAL;\nexports.SOURCE_FORMAT_ARRAY_ROWS = SOURCE_FORMAT_ARRAY_ROWS;\nexports.SOURCE_FORMAT_OBJECT_ROWS = SOURCE_FORMAT_OBJECT_ROWS;\nexports.SOURCE_FORMAT_KEYED_COLUMNS = SOURCE_FORMAT_KEYED_COLUMNS;\nexports.SOURCE_FORMAT_UNKNOWN = SOURCE_FORMAT_UNKNOWN;\nexports.SOURCE_FORMAT_TYPED_ARRAY = SOURCE_FORMAT_TYPED_ARRAY;\nexports.SERIES_LAYOUT_BY_COLUMN = SERIES_LAYOUT_BY_COLUMN;\nexports.SERIES_LAYOUT_BY_ROW = SERIES_LAYOUT_BY_ROW;\n\n/***/ }),\n/* 16 */\n/***/ (function(module, exports) {\n\nvar SHADOW_PROPS = {\n  'shadowBlur': 1,\n  'shadowOffsetX': 1,\n  'shadowOffsetY': 1,\n  'textShadowBlur': 1,\n  'textShadowOffsetX': 1,\n  'textShadowOffsetY': 1,\n  'textBoxShadowBlur': 1,\n  'textBoxShadowOffsetX': 1,\n  'textBoxShadowOffsetY': 1\n};\n\nfunction _default(ctx, propName, value) {\n  if (SHADOW_PROPS.hasOwnProperty(propName)) {\n    return value *= ctx.dpr;\n  }\n\n  return value;\n}\n\nmodule.exports = _default;\n\n/***/ }),\n/* 17 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar guid = __webpack_require__(43);\n\nvar Eventful = __webpack_require__(44);\n\nvar Transformable = __webpack_require__(18);\n\nvar Animatable = __webpack_require__(45);\n\nvar zrUtil = __webpack_require__(0);\n\n/**\n * @alias module:zrender/Element\n * @constructor\n * @extends {module:zrender/mixin/Animatable}\n * @extends {module:zrender/mixin/Transformable}\n * @extends {module:zrender/mixin/Eventful}\n */\nvar Element = function (opts) {\n  // jshint ignore:line\n  Transformable.call(this, opts);\n  Eventful.call(this, opts);\n  Animatable.call(this, opts);\n  /**\n   * 画布元素ID\n   * @type {string}\n   */\n\n  this.id = opts.id || guid();\n};\n\nElement.prototype = {\n  /**\n   * 元素类型\n   * Element type\n   * @type {string}\n   */\n  type: 'element',\n\n  /**\n   * 元素名字\n   * Element name\n   * @type {string}\n   */\n  name: '',\n\n  /**\n   * ZRender 实例对象，会在 element 添加到 zrender 实例中后自动赋值\n   * ZRender instance will be assigned when element is associated with zrender\n   * @name module:/zrender/Element#__zr\n   * @type {module:zrender/ZRender}\n   */\n  __zr: null,\n\n  /**\n   * 图形是否忽略，为true时忽略图形的绘制以及事件触发\n   * If ignore drawing and events of the element object\n   * @name module:/zrender/Element#ignore\n   * @type {boolean}\n   * @default false\n   */\n  ignore: false,\n\n  /**\n   * 用于裁剪的路径(shape)，所有 Group 内的路径在绘制时都会被这个路径裁剪\n   * 该路径会继承被裁减对象的变换\n   * @type {module:zrender/graphic/Path}\n   * @see http://www.w3.org/TR/2dcontext/#clipping-region\n   * @readOnly\n   */\n  clipPath: null,\n\n  /**\n   * 是否是 Group\n   * @type {boolean}\n   */\n  isGroup: false,\n\n  /**\n   * Drift element\n   * @param  {number} dx dx on the global space\n   * @param  {number} dy dy on the global space\n   */\n  drift: function (dx, dy) {\n    switch (this.draggable) {\n      case 'horizontal':\n        dy = 0;\n        break;\n\n      case 'vertical':\n        dx = 0;\n        break;\n    }\n\n    var m = this.transform;\n\n    if (!m) {\n      m = this.transform = [1, 0, 0, 1, 0, 0];\n    }\n\n    m[4] += dx;\n    m[5] += dy;\n    this.decomposeTransform();\n    this.dirty(false);\n  },\n\n  /**\n   * Hook before update\n   */\n  beforeUpdate: function () {},\n\n  /**\n   * Hook after update\n   */\n  afterUpdate: function () {},\n\n  /**\n   * Update each frame\n   */\n  update: function () {\n    this.updateTransform();\n  },\n\n  /**\n   * @param  {Function} cb\n   * @param  {}   context\n   */\n  traverse: function (cb, context) {},\n\n  /**\n   * @protected\n   */\n  attrKV: function (key, value) {\n    if (key === 'position' || key === 'scale' || key === 'origin') {\n      // Copy the array\n      if (value) {\n        var target = this[key];\n\n        if (!target) {\n          target = this[key] = [];\n        }\n\n        target[0] = value[0];\n        target[1] = value[1];\n      }\n    } else {\n      this[key] = value;\n    }\n  },\n\n  /**\n   * Hide the element\n   */\n  hide: function () {\n    this.ignore = true;\n    this.__zr && this.__zr.refresh();\n  },\n\n  /**\n   * Show the element\n   */\n  show: function () {\n    this.ignore = false;\n    this.__zr && this.__zr.refresh();\n  },\n\n  /**\n   * @param {string|Object} key\n   * @param {*} value\n   */\n  attr: function (key, value) {\n    if (typeof key === 'string') {\n      this.attrKV(key, value);\n    } else if (zrUtil.isObject(key)) {\n      for (var name in key) {\n        if (key.hasOwnProperty(name)) {\n          this.attrKV(name, key[name]);\n        }\n      }\n    }\n\n    this.dirty(false);\n    return this;\n  },\n\n  /**\n   * @param {module:zrender/graphic/Path} clipPath\n   */\n  setClipPath: function (clipPath) {\n    var zr = this.__zr;\n\n    if (zr) {\n      clipPath.addSelfToZr(zr);\n    } // Remove previous clip path\n\n\n    if (this.clipPath && this.clipPath !== clipPath) {\n      this.removeClipPath();\n    }\n\n    this.clipPath = clipPath;\n    clipPath.__zr = zr;\n    clipPath.__clipTarget = this;\n    this.dirty(false);\n  },\n\n  /**\n   */\n  removeClipPath: function () {\n    var clipPath = this.clipPath;\n\n    if (clipPath) {\n      if (clipPath.__zr) {\n        clipPath.removeSelfFromZr(clipPath.__zr);\n      }\n\n      clipPath.__zr = null;\n      clipPath.__clipTarget = null;\n      this.clipPath = null;\n      this.dirty(false);\n    }\n  },\n\n  /**\n   * Add self from zrender instance.\n   * Not recursively because it will be invoked when element added to storage.\n   * @param {module:zrender/ZRender} zr\n   */\n  addSelfToZr: function (zr) {\n    this.__zr = zr; // 添加动画\n\n    var animators = this.animators;\n\n    if (animators) {\n      for (var i = 0; i < animators.length; i++) {\n        zr.animation.addAnimator(animators[i]);\n      }\n    }\n\n    if (this.clipPath) {\n      this.clipPath.addSelfToZr(zr);\n    }\n  },\n\n  /**\n   * Remove self from zrender instance.\n   * Not recursively because it will be invoked when element added to storage.\n   * @param {module:zrender/ZRender} zr\n   */\n  removeSelfFromZr: function (zr) {\n    this.__zr = null; // 移除动画\n\n    var animators = this.animators;\n\n    if (animators) {\n      for (var i = 0; i < animators.length; i++) {\n        zr.animation.removeAnimator(animators[i]);\n      }\n    }\n\n    if (this.clipPath) {\n      this.clipPath.removeSelfFromZr(zr);\n    }\n  }\n};\nzrUtil.mixin(Element, Animatable);\nzrUtil.mixin(Element, Transformable);\nzrUtil.mixin(Element, Eventful);\nvar _default = Element;\nmodule.exports = _default;\n\n/***/ }),\n/* 18 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar matrix = __webpack_require__(10);\n\nvar vector = __webpack_require__(2);\n\n/**\n * 提供变换扩展\n * @module zrender/mixin/Transformable\n * @author pissang (https://www.github.com/pissang)\n */\nvar mIdentity = matrix.identity;\nvar EPSILON = 5e-5;\n\nfunction isNotAroundZero(val) {\n  return val > EPSILON || val < -EPSILON;\n}\n/**\n * @alias module:zrender/mixin/Transformable\n * @constructor\n */\n\n\nvar Transformable = function (opts) {\n  opts = opts || {}; // If there are no given position, rotation, scale\n\n  if (!opts.position) {\n    /**\n     * 平移\n     * @type {Array.<number>}\n     * @default [0, 0]\n     */\n    this.position = [0, 0];\n  }\n\n  if (opts.rotation == null) {\n    /**\n     * 旋转\n     * @type {Array.<number>}\n     * @default 0\n     */\n    this.rotation = 0;\n  }\n\n  if (!opts.scale) {\n    /**\n     * 缩放\n     * @type {Array.<number>}\n     * @default [1, 1]\n     */\n    this.scale = [1, 1];\n  }\n  /**\n   * 旋转和缩放的原点\n   * @type {Array.<number>}\n   * @default null\n   */\n\n\n  this.origin = this.origin || null;\n};\n\nvar transformableProto = Transformable.prototype;\ntransformableProto.transform = null;\n/**\n * 判断是否需要有坐标变换\n * 如果有坐标变换, 则从position, rotation, scale以及父节点的transform计算出自身的transform矩阵\n */\n\ntransformableProto.needLocalTransform = function () {\n  return isNotAroundZero(this.rotation) || isNotAroundZero(this.position[0]) || isNotAroundZero(this.position[1]) || isNotAroundZero(this.scale[0] - 1) || isNotAroundZero(this.scale[1] - 1);\n};\n\nvar scaleTmp = [];\n\ntransformableProto.updateTransform = function () {\n  var parent = this.parent;\n  var parentHasTransform = parent && parent.transform;\n  var needLocalTransform = this.needLocalTransform();\n  var m = this.transform;\n\n  if (!(needLocalTransform || parentHasTransform)) {\n    m && mIdentity(m);\n    return;\n  }\n\n  m = m || matrix.create();\n\n  if (needLocalTransform) {\n    this.getLocalTransform(m);\n  } else {\n    mIdentity(m);\n  } // 应用父节点变换\n\n\n  if (parentHasTransform) {\n    if (needLocalTransform) {\n      matrix.mul(m, parent.transform, m);\n    } else {\n      matrix.copy(m, parent.transform);\n    }\n  } // 保存这个变换矩阵\n\n\n  this.transform = m;\n  var globalScaleRatio = this.globalScaleRatio;\n\n  if (globalScaleRatio != null && globalScaleRatio !== 1) {\n    this.getGlobalScale(scaleTmp);\n    var relX = scaleTmp[0] < 0 ? -1 : 1;\n    var relY = scaleTmp[1] < 0 ? -1 : 1;\n    var sx = ((scaleTmp[0] - relX) * globalScaleRatio + relX) / scaleTmp[0] || 0;\n    var sy = ((scaleTmp[1] - relY) * globalScaleRatio + relY) / scaleTmp[1] || 0;\n    m[0] *= sx;\n    m[1] *= sx;\n    m[2] *= sy;\n    m[3] *= sy;\n  }\n\n  this.invTransform = this.invTransform || matrix.create();\n  matrix.invert(this.invTransform, m);\n};\n\ntransformableProto.getLocalTransform = function (m) {\n  return Transformable.getLocalTransform(this, m);\n};\n/**\n * 将自己的transform应用到context上\n * @param {CanvasRenderingContext2D} ctx\n */\n\n\ntransformableProto.setTransform = function (ctx) {\n  var m = this.transform;\n  var dpr = ctx.dpr || 1;\n\n  if (m) {\n    ctx.setTransform(dpr * m[0], dpr * m[1], dpr * m[2], dpr * m[3], dpr * m[4], dpr * m[5]);\n  } else {\n    ctx.setTransform(dpr, 0, 0, dpr, 0, 0);\n  }\n};\n\ntransformableProto.restoreTransform = function (ctx) {\n  var dpr = ctx.dpr || 1;\n  ctx.setTransform(dpr, 0, 0, dpr, 0, 0);\n};\n\nvar tmpTransform = [];\nvar originTransform = matrix.create();\n\ntransformableProto.setLocalTransform = function (m) {\n  if (!m) {\n    // TODO return or set identity?\n    return;\n  }\n\n  var sx = m[0] * m[0] + m[1] * m[1];\n  var sy = m[2] * m[2] + m[3] * m[3];\n  var position = this.position;\n  var scale = this.scale;\n\n  if (isNotAroundZero(sx - 1)) {\n    sx = Math.sqrt(sx);\n  }\n\n  if (isNotAroundZero(sy - 1)) {\n    sy = Math.sqrt(sy);\n  }\n\n  if (m[0] < 0) {\n    sx = -sx;\n  }\n\n  if (m[3] < 0) {\n    sy = -sy;\n  }\n\n  position[0] = m[4];\n  position[1] = m[5];\n  scale[0] = sx;\n  scale[1] = sy;\n  this.rotation = Math.atan2(-m[1] / sy, m[0] / sx);\n};\n/**\n * 分解`transform`矩阵到`position`, `rotation`, `scale`\n */\n\n\ntransformableProto.decomposeTransform = function () {\n  if (!this.transform) {\n    return;\n  }\n\n  var parent = this.parent;\n  var m = this.transform;\n\n  if (parent && parent.transform) {\n    // Get local transform and decompose them to position, scale, rotation\n    matrix.mul(tmpTransform, parent.invTransform, m);\n    m = tmpTransform;\n  }\n\n  var origin = this.origin;\n\n  if (origin && (origin[0] || origin[1])) {\n    originTransform[4] = origin[0];\n    originTransform[5] = origin[1];\n    matrix.mul(tmpTransform, m, originTransform);\n    tmpTransform[4] -= origin[0];\n    tmpTransform[5] -= origin[1];\n    m = tmpTransform;\n  }\n\n  this.setLocalTransform(m);\n};\n/**\n * Get global scale\n * @return {Array.<number>}\n */\n\n\ntransformableProto.getGlobalScale = function (out) {\n  var m = this.transform;\n  out = out || [];\n\n  if (!m) {\n    out[0] = 1;\n    out[1] = 1;\n    return out;\n  }\n\n  out[0] = Math.sqrt(m[0] * m[0] + m[1] * m[1]);\n  out[1] = Math.sqrt(m[2] * m[2] + m[3] * m[3]);\n\n  if (m[0] < 0) {\n    out[0] = -out[0];\n  }\n\n  if (m[3] < 0) {\n    out[1] = -out[1];\n  }\n\n  return out;\n};\n/**\n * 变换坐标位置到 shape 的局部坐标空间\n * @method\n * @param {number} x\n * @param {number} y\n * @return {Array.<number>}\n */\n\n\ntransformableProto.transformCoordToLocal = function (x, y) {\n  var v2 = [x, y];\n  var invTransform = this.invTransform;\n\n  if (invTransform) {\n    vector.applyTransform(v2, v2, invTransform);\n  }\n\n  return v2;\n};\n/**\n * 变换局部坐标位置到全局坐标空间\n * @method\n * @param {number} x\n * @param {number} y\n * @return {Array.<number>}\n */\n\n\ntransformableProto.transformCoordToGlobal = function (x, y) {\n  var v2 = [x, y];\n  var transform = this.transform;\n\n  if (transform) {\n    vector.applyTransform(v2, v2, transform);\n  }\n\n  return v2;\n};\n/**\n * @static\n * @param {Object} target\n * @param {Array.<number>} target.origin\n * @param {number} target.rotation\n * @param {Array.<number>} target.position\n * @param {Array.<number>} [m]\n */\n\n\nTransformable.getLocalTransform = function (target, m) {\n  m = m || [];\n  mIdentity(m);\n  var origin = target.origin;\n  var scale = target.scale || [1, 1];\n  var rotation = target.rotation || 0;\n  var position = target.position || [0, 0];\n\n  if (origin) {\n    // Translate to origin\n    m[4] -= origin[0];\n    m[5] -= origin[1];\n  }\n\n  matrix.scale(m, m, scale);\n\n  if (rotation) {\n    matrix.rotate(m, m, rotation);\n  }\n\n  if (origin) {\n    // Translate back from origin\n    m[4] += origin[0];\n    m[5] += origin[1];\n  }\n\n  m[4] += position[0];\n  m[5] += position[1];\n  return m;\n};\n\nvar _default = Transformable;\nmodule.exports = _default;\n\n/***/ }),\n/* 19 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar LRU = __webpack_require__(20);\n\nvar kCSSColorTable = {\n  'transparent': [0, 0, 0, 0],\n  'aliceblue': [240, 248, 255, 1],\n  'antiquewhite': [250, 235, 215, 1],\n  'aqua': [0, 255, 255, 1],\n  'aquamarine': [127, 255, 212, 1],\n  'azure': [240, 255, 255, 1],\n  'beige': [245, 245, 220, 1],\n  'bisque': [255, 228, 196, 1],\n  'black': [0, 0, 0, 1],\n  'blanchedalmond': [255, 235, 205, 1],\n  'blue': [0, 0, 255, 1],\n  'blueviolet': [138, 43, 226, 1],\n  'brown': [165, 42, 42, 1],\n  'burlywood': [222, 184, 135, 1],\n  'cadetblue': [95, 158, 160, 1],\n  'chartreuse': [127, 255, 0, 1],\n  'chocolate': [210, 105, 30, 1],\n  'coral': [255, 127, 80, 1],\n  'cornflowerblue': [100, 149, 237, 1],\n  'cornsilk': [255, 248, 220, 1],\n  'crimson': [220, 20, 60, 1],\n  'cyan': [0, 255, 255, 1],\n  'darkblue': [0, 0, 139, 1],\n  'darkcyan': [0, 139, 139, 1],\n  'darkgoldenrod': [184, 134, 11, 1],\n  'darkgray': [169, 169, 169, 1],\n  'darkgreen': [0, 100, 0, 1],\n  'darkgrey': [169, 169, 169, 1],\n  'darkkhaki': [189, 183, 107, 1],\n  'darkmagenta': [139, 0, 139, 1],\n  'darkolivegreen': [85, 107, 47, 1],\n  'darkorange': [255, 140, 0, 1],\n  'darkorchid': [153, 50, 204, 1],\n  'darkred': [139, 0, 0, 1],\n  'darksalmon': [233, 150, 122, 1],\n  'darkseagreen': [143, 188, 143, 1],\n  'darkslateblue': [72, 61, 139, 1],\n  'darkslategray': [47, 79, 79, 1],\n  'darkslategrey': [47, 79, 79, 1],\n  'darkturquoise': [0, 206, 209, 1],\n  'darkviolet': [148, 0, 211, 1],\n  'deeppink': [255, 20, 147, 1],\n  'deepskyblue': [0, 191, 255, 1],\n  'dimgray': [105, 105, 105, 1],\n  'dimgrey': [105, 105, 105, 1],\n  'dodgerblue': [30, 144, 255, 1],\n  'firebrick': [178, 34, 34, 1],\n  'floralwhite': [255, 250, 240, 1],\n  'forestgreen': [34, 139, 34, 1],\n  'fuchsia': [255, 0, 255, 1],\n  'gainsboro': [220, 220, 220, 1],\n  'ghostwhite': [248, 248, 255, 1],\n  'gold': [255, 215, 0, 1],\n  'goldenrod': [218, 165, 32, 1],\n  'gray': [128, 128, 128, 1],\n  'green': [0, 128, 0, 1],\n  'greenyellow': [173, 255, 47, 1],\n  'grey': [128, 128, 128, 1],\n  'honeydew': [240, 255, 240, 1],\n  'hotpink': [255, 105, 180, 1],\n  'indianred': [205, 92, 92, 1],\n  'indigo': [75, 0, 130, 1],\n  'ivory': [255, 255, 240, 1],\n  'khaki': [240, 230, 140, 1],\n  'lavender': [230, 230, 250, 1],\n  'lavenderblush': [255, 240, 245, 1],\n  'lawngreen': [124, 252, 0, 1],\n  'lemonchiffon': [255, 250, 205, 1],\n  'lightblue': [173, 216, 230, 1],\n  'lightcoral': [240, 128, 128, 1],\n  'lightcyan': [224, 255, 255, 1],\n  'lightgoldenrodyellow': [250, 250, 210, 1],\n  'lightgray': [211, 211, 211, 1],\n  'lightgreen': [144, 238, 144, 1],\n  'lightgrey': [211, 211, 211, 1],\n  'lightpink': [255, 182, 193, 1],\n  'lightsalmon': [255, 160, 122, 1],\n  'lightseagreen': [32, 178, 170, 1],\n  'lightskyblue': [135, 206, 250, 1],\n  'lightslategray': [119, 136, 153, 1],\n  'lightslategrey': [119, 136, 153, 1],\n  'lightsteelblue': [176, 196, 222, 1],\n  'lightyellow': [255, 255, 224, 1],\n  'lime': [0, 255, 0, 1],\n  'limegreen': [50, 205, 50, 1],\n  'linen': [250, 240, 230, 1],\n  'magenta': [255, 0, 255, 1],\n  'maroon': [128, 0, 0, 1],\n  'mediumaquamarine': [102, 205, 170, 1],\n  'mediumblue': [0, 0, 205, 1],\n  'mediumorchid': [186, 85, 211, 1],\n  'mediumpurple': [147, 112, 219, 1],\n  'mediumseagreen': [60, 179, 113, 1],\n  'mediumslateblue': [123, 104, 238, 1],\n  'mediumspringgreen': [0, 250, 154, 1],\n  'mediumturquoise': [72, 209, 204, 1],\n  'mediumvioletred': [199, 21, 133, 1],\n  'midnightblue': [25, 25, 112, 1],\n  'mintcream': [245, 255, 250, 1],\n  'mistyrose': [255, 228, 225, 1],\n  'moccasin': [255, 228, 181, 1],\n  'navajowhite': [255, 222, 173, 1],\n  'navy': [0, 0, 128, 1],\n  'oldlace': [253, 245, 230, 1],\n  'olive': [128, 128, 0, 1],\n  'olivedrab': [107, 142, 35, 1],\n  'orange': [255, 165, 0, 1],\n  'orangered': [255, 69, 0, 1],\n  'orchid': [218, 112, 214, 1],\n  'palegoldenrod': [238, 232, 170, 1],\n  'palegreen': [152, 251, 152, 1],\n  'paleturquoise': [175, 238, 238, 1],\n  'palevioletred': [219, 112, 147, 1],\n  'papayawhip': [255, 239, 213, 1],\n  'peachpuff': [255, 218, 185, 1],\n  'peru': [205, 133, 63, 1],\n  'pink': [255, 192, 203, 1],\n  'plum': [221, 160, 221, 1],\n  'powderblue': [176, 224, 230, 1],\n  'purple': [128, 0, 128, 1],\n  'red': [255, 0, 0, 1],\n  'rosybrown': [188, 143, 143, 1],\n  'royalblue': [65, 105, 225, 1],\n  'saddlebrown': [139, 69, 19, 1],\n  'salmon': [250, 128, 114, 1],\n  'sandybrown': [244, 164, 96, 1],\n  'seagreen': [46, 139, 87, 1],\n  'seashell': [255, 245, 238, 1],\n  'sienna': [160, 82, 45, 1],\n  'silver': [192, 192, 192, 1],\n  'skyblue': [135, 206, 235, 1],\n  'slateblue': [106, 90, 205, 1],\n  'slategray': [112, 128, 144, 1],\n  'slategrey': [112, 128, 144, 1],\n  'snow': [255, 250, 250, 1],\n  'springgreen': [0, 255, 127, 1],\n  'steelblue': [70, 130, 180, 1],\n  'tan': [210, 180, 140, 1],\n  'teal': [0, 128, 128, 1],\n  'thistle': [216, 191, 216, 1],\n  'tomato': [255, 99, 71, 1],\n  'turquoise': [64, 224, 208, 1],\n  'violet': [238, 130, 238, 1],\n  'wheat': [245, 222, 179, 1],\n  'white': [255, 255, 255, 1],\n  'whitesmoke': [245, 245, 245, 1],\n  'yellow': [255, 255, 0, 1],\n  'yellowgreen': [154, 205, 50, 1]\n};\n\nfunction clampCssByte(i) {\n  // Clamp to integer 0 .. 255.\n  i = Math.round(i); // Seems to be what Chrome does (vs truncation).\n\n  return i < 0 ? 0 : i > 255 ? 255 : i;\n}\n\nfunction clampCssAngle(i) {\n  // Clamp to integer 0 .. 360.\n  i = Math.round(i); // Seems to be what Chrome does (vs truncation).\n\n  return i < 0 ? 0 : i > 360 ? 360 : i;\n}\n\nfunction clampCssFloat(f) {\n  // Clamp to float 0.0 .. 1.0.\n  return f < 0 ? 0 : f > 1 ? 1 : f;\n}\n\nfunction parseCssInt(str) {\n  // int or percentage.\n  if (str.length && str.charAt(str.length - 1) === '%') {\n    return clampCssByte(parseFloat(str) / 100 * 255);\n  }\n\n  return clampCssByte(parseInt(str, 10));\n}\n\nfunction parseCssFloat(str) {\n  // float or percentage.\n  if (str.length && str.charAt(str.length - 1) === '%') {\n    return clampCssFloat(parseFloat(str) / 100);\n  }\n\n  return clampCssFloat(parseFloat(str));\n}\n\nfunction cssHueToRgb(m1, m2, h) {\n  if (h < 0) {\n    h += 1;\n  } else if (h > 1) {\n    h -= 1;\n  }\n\n  if (h * 6 < 1) {\n    return m1 + (m2 - m1) * h * 6;\n  }\n\n  if (h * 2 < 1) {\n    return m2;\n  }\n\n  if (h * 3 < 2) {\n    return m1 + (m2 - m1) * (2 / 3 - h) * 6;\n  }\n\n  return m1;\n}\n\nfunction lerpNumber(a, b, p) {\n  return a + (b - a) * p;\n}\n\nfunction setRgba(out, r, g, b, a) {\n  out[0] = r;\n  out[1] = g;\n  out[2] = b;\n  out[3] = a;\n  return out;\n}\n\nfunction copyRgba(out, a) {\n  out[0] = a[0];\n  out[1] = a[1];\n  out[2] = a[2];\n  out[3] = a[3];\n  return out;\n}\n\nvar colorCache = new LRU(20);\nvar lastRemovedArr = null;\n\nfunction putToCache(colorStr, rgbaArr) {\n  // Reuse removed array\n  if (lastRemovedArr) {\n    copyRgba(lastRemovedArr, rgbaArr);\n  }\n\n  lastRemovedArr = colorCache.put(colorStr, lastRemovedArr || rgbaArr.slice());\n}\n/**\n * @param {string} colorStr\n * @param {Array.<number>} out\n * @return {Array.<number>}\n * @memberOf module:zrender/util/color\n */\n\n\nfunction parse(colorStr, rgbaArr) {\n  if (!colorStr) {\n    return;\n  }\n\n  rgbaArr = rgbaArr || [];\n  var cached = colorCache.get(colorStr);\n\n  if (cached) {\n    return copyRgba(rgbaArr, cached);\n  } // colorStr may be not string\n\n\n  colorStr = colorStr + ''; // Remove all whitespace, not compliant, but should just be more accepting.\n\n  var str = colorStr.replace(/ /g, '').toLowerCase(); // Color keywords (and transparent) lookup.\n\n  if (str in kCSSColorTable) {\n    copyRgba(rgbaArr, kCSSColorTable[str]);\n    putToCache(colorStr, rgbaArr);\n    return rgbaArr;\n  } // #abc and #abc123 syntax.\n\n\n  if (str.charAt(0) === '#') {\n    if (str.length === 4) {\n      var iv = parseInt(str.substr(1), 16); // TODO(deanm): Stricter parsing.\n\n      if (!(iv >= 0 && iv <= 0xfff)) {\n        setRgba(rgbaArr, 0, 0, 0, 1);\n        return; // Covers NaN.\n      }\n\n      setRgba(rgbaArr, (iv & 0xf00) >> 4 | (iv & 0xf00) >> 8, iv & 0xf0 | (iv & 0xf0) >> 4, iv & 0xf | (iv & 0xf) << 4, 1);\n      putToCache(colorStr, rgbaArr);\n      return rgbaArr;\n    } else if (str.length === 7) {\n      var iv = parseInt(str.substr(1), 16); // TODO(deanm): Stricter parsing.\n\n      if (!(iv >= 0 && iv <= 0xffffff)) {\n        setRgba(rgbaArr, 0, 0, 0, 1);\n        return; // Covers NaN.\n      }\n\n      setRgba(rgbaArr, (iv & 0xff0000) >> 16, (iv & 0xff00) >> 8, iv & 0xff, 1);\n      putToCache(colorStr, rgbaArr);\n      return rgbaArr;\n    }\n\n    return;\n  }\n\n  var op = str.indexOf('(');\n  var ep = str.indexOf(')');\n\n  if (op !== -1 && ep + 1 === str.length) {\n    var fname = str.substr(0, op);\n    var params = str.substr(op + 1, ep - (op + 1)).split(',');\n    var alpha = 1; // To allow case fallthrough.\n\n    switch (fname) {\n      case 'rgba':\n        if (params.length !== 4) {\n          setRgba(rgbaArr, 0, 0, 0, 1);\n          return;\n        }\n\n        alpha = parseCssFloat(params.pop());\n      // jshint ignore:line\n      // Fall through.\n\n      case 'rgb':\n        if (params.length !== 3) {\n          setRgba(rgbaArr, 0, 0, 0, 1);\n          return;\n        }\n\n        setRgba(rgbaArr, parseCssInt(params[0]), parseCssInt(params[1]), parseCssInt(params[2]), alpha);\n        putToCache(colorStr, rgbaArr);\n        return rgbaArr;\n\n      case 'hsla':\n        if (params.length !== 4) {\n          setRgba(rgbaArr, 0, 0, 0, 1);\n          return;\n        }\n\n        params[3] = parseCssFloat(params[3]);\n        hsla2rgba(params, rgbaArr);\n        putToCache(colorStr, rgbaArr);\n        return rgbaArr;\n\n      case 'hsl':\n        if (params.length !== 3) {\n          setRgba(rgbaArr, 0, 0, 0, 1);\n          return;\n        }\n\n        hsla2rgba(params, rgbaArr);\n        putToCache(colorStr, rgbaArr);\n        return rgbaArr;\n\n      default:\n        return;\n    }\n  }\n\n  setRgba(rgbaArr, 0, 0, 0, 1);\n  return;\n}\n/**\n * @param {Array.<number>} hsla\n * @param {Array.<number>} rgba\n * @return {Array.<number>} rgba\n */\n\n\nfunction hsla2rgba(hsla, rgba) {\n  var h = (parseFloat(hsla[0]) % 360 + 360) % 360 / 360; // 0 .. 1\n  // NOTE(deanm): According to the CSS spec s/l should only be\n  // percentages, but we don't bother and let float or percentage.\n\n  var s = parseCssFloat(hsla[1]);\n  var l = parseCssFloat(hsla[2]);\n  var m2 = l <= 0.5 ? l * (s + 1) : l + s - l * s;\n  var m1 = l * 2 - m2;\n  rgba = rgba || [];\n  setRgba(rgba, clampCssByte(cssHueToRgb(m1, m2, h + 1 / 3) * 255), clampCssByte(cssHueToRgb(m1, m2, h) * 255), clampCssByte(cssHueToRgb(m1, m2, h - 1 / 3) * 255), 1);\n\n  if (hsla.length === 4) {\n    rgba[3] = hsla[3];\n  }\n\n  return rgba;\n}\n/**\n * @param {Array.<number>} rgba\n * @return {Array.<number>} hsla\n */\n\n\nfunction rgba2hsla(rgba) {\n  if (!rgba) {\n    return;\n  } // RGB from 0 to 255\n\n\n  var R = rgba[0] / 255;\n  var G = rgba[1] / 255;\n  var B = rgba[2] / 255;\n  var vMin = Math.min(R, G, B); // Min. value of RGB\n\n  var vMax = Math.max(R, G, B); // Max. value of RGB\n\n  var delta = vMax - vMin; // Delta RGB value\n\n  var L = (vMax + vMin) / 2;\n  var H;\n  var S; // HSL results from 0 to 1\n\n  if (delta === 0) {\n    H = 0;\n    S = 0;\n  } else {\n    if (L < 0.5) {\n      S = delta / (vMax + vMin);\n    } else {\n      S = delta / (2 - vMax - vMin);\n    }\n\n    var deltaR = ((vMax - R) / 6 + delta / 2) / delta;\n    var deltaG = ((vMax - G) / 6 + delta / 2) / delta;\n    var deltaB = ((vMax - B) / 6 + delta / 2) / delta;\n\n    if (R === vMax) {\n      H = deltaB - deltaG;\n    } else if (G === vMax) {\n      H = 1 / 3 + deltaR - deltaB;\n    } else if (B === vMax) {\n      H = 2 / 3 + deltaG - deltaR;\n    }\n\n    if (H < 0) {\n      H += 1;\n    }\n\n    if (H > 1) {\n      H -= 1;\n    }\n  }\n\n  var hsla = [H * 360, S, L];\n\n  if (rgba[3] != null) {\n    hsla.push(rgba[3]);\n  }\n\n  return hsla;\n}\n/**\n * @param {string} color\n * @param {number} level\n * @return {string}\n * @memberOf module:zrender/util/color\n */\n\n\nfunction lift(color, level) {\n  var colorArr = parse(color);\n\n  if (colorArr) {\n    for (var i = 0; i < 3; i++) {\n      if (level < 0) {\n        colorArr[i] = colorArr[i] * (1 - level) | 0;\n      } else {\n        colorArr[i] = (255 - colorArr[i]) * level + colorArr[i] | 0;\n      }\n\n      if (colorArr[i] > 255) {\n        colorArr[i] = 255;\n      } else if (color[i] < 0) {\n        colorArr[i] = 0;\n      }\n    }\n\n    return stringify(colorArr, colorArr.length === 4 ? 'rgba' : 'rgb');\n  }\n}\n/**\n * @param {string} color\n * @return {string}\n * @memberOf module:zrender/util/color\n */\n\n\nfunction toHex(color) {\n  var colorArr = parse(color);\n\n  if (colorArr) {\n    return ((1 << 24) + (colorArr[0] << 16) + (colorArr[1] << 8) + +colorArr[2]).toString(16).slice(1);\n  }\n}\n/**\n * Map value to color. Faster than lerp methods because color is represented by rgba array.\n * @param {number} normalizedValue A float between 0 and 1.\n * @param {Array.<Array.<number>>} colors List of rgba color array\n * @param {Array.<number>} [out] Mapped gba color array\n * @return {Array.<number>} will be null/undefined if input illegal.\n */\n\n\nfunction fastLerp(normalizedValue, colors, out) {\n  if (!(colors && colors.length) || !(normalizedValue >= 0 && normalizedValue <= 1)) {\n    return;\n  }\n\n  out = out || [];\n  var value = normalizedValue * (colors.length - 1);\n  var leftIndex = Math.floor(value);\n  var rightIndex = Math.ceil(value);\n  var leftColor = colors[leftIndex];\n  var rightColor = colors[rightIndex];\n  var dv = value - leftIndex;\n  out[0] = clampCssByte(lerpNumber(leftColor[0], rightColor[0], dv));\n  out[1] = clampCssByte(lerpNumber(leftColor[1], rightColor[1], dv));\n  out[2] = clampCssByte(lerpNumber(leftColor[2], rightColor[2], dv));\n  out[3] = clampCssFloat(lerpNumber(leftColor[3], rightColor[3], dv));\n  return out;\n}\n/**\n * @deprecated\n */\n\n\nvar fastMapToColor = fastLerp;\n/**\n * @param {number} normalizedValue A float between 0 and 1.\n * @param {Array.<string>} colors Color list.\n * @param {boolean=} fullOutput Default false.\n * @return {(string|Object)} Result color. If fullOutput,\n *                           return {color: ..., leftIndex: ..., rightIndex: ..., value: ...},\n * @memberOf module:zrender/util/color\n */\n\nfunction lerp(normalizedValue, colors, fullOutput) {\n  if (!(colors && colors.length) || !(normalizedValue >= 0 && normalizedValue <= 1)) {\n    return;\n  }\n\n  var value = normalizedValue * (colors.length - 1);\n  var leftIndex = Math.floor(value);\n  var rightIndex = Math.ceil(value);\n  var leftColor = parse(colors[leftIndex]);\n  var rightColor = parse(colors[rightIndex]);\n  var dv = value - leftIndex;\n  var color = stringify([clampCssByte(lerpNumber(leftColor[0], rightColor[0], dv)), clampCssByte(lerpNumber(leftColor[1], rightColor[1], dv)), clampCssByte(lerpNumber(leftColor[2], rightColor[2], dv)), clampCssFloat(lerpNumber(leftColor[3], rightColor[3], dv))], 'rgba');\n  return fullOutput ? {\n    color: color,\n    leftIndex: leftIndex,\n    rightIndex: rightIndex,\n    value: value\n  } : color;\n}\n/**\n * @deprecated\n */\n\n\nvar mapToColor = lerp;\n/**\n * @param {string} color\n * @param {number=} h 0 ~ 360, ignore when null.\n * @param {number=} s 0 ~ 1, ignore when null.\n * @param {number=} l 0 ~ 1, ignore when null.\n * @return {string} Color string in rgba format.\n * @memberOf module:zrender/util/color\n */\n\nfunction modifyHSL(color, h, s, l) {\n  color = parse(color);\n\n  if (color) {\n    color = rgba2hsla(color);\n    h != null && (color[0] = clampCssAngle(h));\n    s != null && (color[1] = parseCssFloat(s));\n    l != null && (color[2] = parseCssFloat(l));\n    return stringify(hsla2rgba(color), 'rgba');\n  }\n}\n/**\n * @param {string} color\n * @param {number=} alpha 0 ~ 1\n * @return {string} Color string in rgba format.\n * @memberOf module:zrender/util/color\n */\n\n\nfunction modifyAlpha(color, alpha) {\n  color = parse(color);\n\n  if (color && alpha != null) {\n    color[3] = clampCssFloat(alpha);\n    return stringify(color, 'rgba');\n  }\n}\n/**\n * @param {Array.<number>} arrColor like [12,33,44,0.4]\n * @param {string} type 'rgba', 'hsva', ...\n * @return {string} Result color. (If input illegal, return undefined).\n */\n\n\nfunction stringify(arrColor, type) {\n  if (!arrColor || !arrColor.length) {\n    return;\n  }\n\n  var colorStr = arrColor[0] + ',' + arrColor[1] + ',' + arrColor[2];\n\n  if (type === 'rgba' || type === 'hsva' || type === 'hsla') {\n    colorStr += ',' + arrColor[3];\n  }\n\n  return type + '(' + colorStr + ')';\n}\n\nexports.parse = parse;\nexports.lift = lift;\nexports.toHex = toHex;\nexports.fastLerp = fastLerp;\nexports.fastMapToColor = fastMapToColor;\nexports.lerp = lerp;\nexports.mapToColor = mapToColor;\nexports.modifyHSL = modifyHSL;\nexports.modifyAlpha = modifyAlpha;\nexports.stringify = stringify;\n\n/***/ }),\n/* 20 */\n/***/ (function(module, exports) {\n\n// Simple LRU cache use doubly linked list\n// @module zrender/core/LRU\n\n/**\n * Simple double linked list. Compared with array, it has O(1) remove operation.\n * @constructor\n */\nvar LinkedList = function () {\n  /**\n   * @type {module:zrender/core/LRU~Entry}\n   */\n  this.head = null;\n  /**\n   * @type {module:zrender/core/LRU~Entry}\n   */\n\n  this.tail = null;\n  this._len = 0;\n};\n\nvar linkedListProto = LinkedList.prototype;\n/**\n * Insert a new value at the tail\n * @param  {} val\n * @return {module:zrender/core/LRU~Entry}\n */\n\nlinkedListProto.insert = function (val) {\n  var entry = new Entry(val);\n  this.insertEntry(entry);\n  return entry;\n};\n/**\n * Insert an entry at the tail\n * @param  {module:zrender/core/LRU~Entry} entry\n */\n\n\nlinkedListProto.insertEntry = function (entry) {\n  if (!this.head) {\n    this.head = this.tail = entry;\n  } else {\n    this.tail.next = entry;\n    entry.prev = this.tail;\n    entry.next = null;\n    this.tail = entry;\n  }\n\n  this._len++;\n};\n/**\n * Remove entry.\n * @param  {module:zrender/core/LRU~Entry} entry\n */\n\n\nlinkedListProto.remove = function (entry) {\n  var prev = entry.prev;\n  var next = entry.next;\n\n  if (prev) {\n    prev.next = next;\n  } else {\n    // Is head\n    this.head = next;\n  }\n\n  if (next) {\n    next.prev = prev;\n  } else {\n    // Is tail\n    this.tail = prev;\n  }\n\n  entry.next = entry.prev = null;\n  this._len--;\n};\n/**\n * @return {number}\n */\n\n\nlinkedListProto.len = function () {\n  return this._len;\n};\n/**\n * Clear list\n */\n\n\nlinkedListProto.clear = function () {\n  this.head = this.tail = null;\n  this._len = 0;\n};\n/**\n * @constructor\n * @param {} val\n */\n\n\nvar Entry = function (val) {\n  /**\n   * @type {}\n   */\n  this.value = val;\n  /**\n   * @type {module:zrender/core/LRU~Entry}\n   */\n\n  this.next;\n  /**\n   * @type {module:zrender/core/LRU~Entry}\n   */\n\n  this.prev;\n};\n/**\n * LRU Cache\n * @constructor\n * @alias module:zrender/core/LRU\n */\n\n\nvar LRU = function (maxSize) {\n  this._list = new LinkedList();\n  this._map = {};\n  this._maxSize = maxSize || 10;\n  this._lastRemovedEntry = null;\n};\n\nvar LRUProto = LRU.prototype;\n/**\n * @param  {string} key\n * @param  {} value\n * @return {} Removed value\n */\n\nLRUProto.put = function (key, value) {\n  var list = this._list;\n  var map = this._map;\n  var removed = null;\n\n  if (map[key] == null) {\n    var len = list.len(); // Reuse last removed entry\n\n    var entry = this._lastRemovedEntry;\n\n    if (len >= this._maxSize && len > 0) {\n      // Remove the least recently used\n      var leastUsedEntry = list.head;\n      list.remove(leastUsedEntry);\n      delete map[leastUsedEntry.key];\n      removed = leastUsedEntry.value;\n      this._lastRemovedEntry = leastUsedEntry;\n    }\n\n    if (entry) {\n      entry.value = value;\n    } else {\n      entry = new Entry(value);\n    }\n\n    entry.key = key;\n    list.insertEntry(entry);\n    map[key] = entry;\n  }\n\n  return removed;\n};\n/**\n * @param  {string} key\n * @return {}\n */\n\n\nLRUProto.get = function (key) {\n  var entry = this._map[key];\n  var list = this._list;\n\n  if (entry != null) {\n    // Put the latest used entry in the tail\n    if (entry !== list.tail) {\n      list.remove(entry);\n      list.insertEntry(entry);\n    }\n\n    return entry.value;\n  }\n};\n/**\n * Clear the cache\n */\n\n\nLRUProto.clear = function () {\n  this._list.clear();\n\n  this._map = {};\n};\n\nvar _default = LRU;\nmodule.exports = _default;\n\n/***/ }),\n/* 21 */\n/***/ (function(module, exports) {\n\nvar dpr = 1; // If in browser environment\n\nif (typeof window !== 'undefined') {\n  dpr = Math.max(window.devicePixelRatio || 1, 1);\n}\n/**\n * config默认配置项\n * @exports zrender/config\n * @author Kener (@Kener-林峰, kener.linfeng@gmail.com)\n */\n\n/**\n * debug日志选项：catchBrushException为true下有效\n * 0 : 不生成debug数据，发布用\n * 1 : 异常抛出，调试用\n * 2 : 控制台输出，调试用\n */\n\n\nvar debugMode = 0; // retina 屏幕优化\n\nvar devicePixelRatio = dpr;\nexports.debugMode = debugMode;\nexports.devicePixelRatio = devicePixelRatio;\n\n/***/ }),\n/* 22 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar _util = __webpack_require__(0);\n\nvar retrieve2 = _util.retrieve2;\nvar retrieve3 = _util.retrieve3;\nvar each = _util.each;\nvar normalizeCssArray = _util.normalizeCssArray;\nvar isString = _util.isString;\nvar isObject = _util.isObject;\n\nvar textContain = __webpack_require__(23);\n\nvar roundRectHelper = __webpack_require__(24);\n\nvar imageHelper = __webpack_require__(11);\n\nvar fixShadow = __webpack_require__(16);\n\nvar _constant = __webpack_require__(8);\n\nvar ContextCachedBy = _constant.ContextCachedBy;\nvar WILL_BE_RESTORED = _constant.WILL_BE_RESTORED;\nvar DEFAULT_FONT = textContain.DEFAULT_FONT; // TODO: Have not support 'start', 'end' yet.\n\nvar VALID_TEXT_ALIGN = {\n  left: 1,\n  right: 1,\n  center: 1\n};\nvar VALID_TEXT_VERTICAL_ALIGN = {\n  top: 1,\n  bottom: 1,\n  middle: 1\n}; // Different from `STYLE_COMMON_PROPS` of `graphic/Style`,\n// the default value of shadowColor is `'transparent'`.\n\nvar SHADOW_STYLE_COMMON_PROPS = [['textShadowBlur', 'shadowBlur', 0], ['textShadowOffsetX', 'shadowOffsetX', 0], ['textShadowOffsetY', 'shadowOffsetY', 0], ['textShadowColor', 'shadowColor', 'transparent']];\n/**\n * @param {module:zrender/graphic/Style} style\n * @return {module:zrender/graphic/Style} The input style.\n */\n\nfunction normalizeTextStyle(style) {\n  normalizeStyle(style);\n  each(style.rich, normalizeStyle);\n  return style;\n}\n\nfunction normalizeStyle(style) {\n  if (style) {\n    style.font = textContain.makeFont(style);\n    var textAlign = style.textAlign;\n    textAlign === 'middle' && (textAlign = 'center');\n    style.textAlign = textAlign == null || VALID_TEXT_ALIGN[textAlign] ? textAlign : 'left'; // Compatible with textBaseline.\n\n    var textVerticalAlign = style.textVerticalAlign || style.textBaseline;\n    textVerticalAlign === 'center' && (textVerticalAlign = 'middle');\n    style.textVerticalAlign = textVerticalAlign == null || VALID_TEXT_VERTICAL_ALIGN[textVerticalAlign] ? textVerticalAlign : 'top';\n    var textPadding = style.textPadding;\n\n    if (textPadding) {\n      style.textPadding = normalizeCssArray(style.textPadding);\n    }\n  }\n}\n/**\n * @param {CanvasRenderingContext2D} ctx\n * @param {string} text\n * @param {module:zrender/graphic/Style} style\n * @param {Object|boolean} [rect] {x, y, width, height}\n *                  If set false, rect text is not used.\n * @param {Element|module:zrender/graphic/helper/constant.WILL_BE_RESTORED} [prevEl] For ctx prop cache.\n */\n\n\nfunction renderText(hostEl, ctx, text, style, rect, prevEl) {\n  style.rich ? renderRichText(hostEl, ctx, text, style, rect, prevEl) : renderPlainText(hostEl, ctx, text, style, rect, prevEl);\n} // Avoid setting to ctx according to prevEl if possible for\n// performance in scenarios of large amount text.\n\n\nfunction renderPlainText(hostEl, ctx, text, style, rect, prevEl) {\n  'use strict';\n\n  var needDrawBg = needDrawBackground(style);\n  var prevStyle;\n  var checkCache = false;\n  var cachedByMe = ctx.__attrCachedBy === ContextCachedBy.PLAIN_TEXT; // Only take and check cache for `Text` el, but not RectText.\n\n  if (prevEl !== WILL_BE_RESTORED) {\n    if (prevEl) {\n      prevStyle = prevEl.style;\n      checkCache = !needDrawBg && cachedByMe && prevStyle;\n    } // Prevent from using cache in `Style::bind`, because of the case:\n    // ctx property is modified by other properties than `Style::bind`\n    // used, and Style::bind is called next.\n\n\n    ctx.__attrCachedBy = needDrawBg ? ContextCachedBy.NONE : ContextCachedBy.PLAIN_TEXT;\n  } // Since this will be restored, prevent from using these props to check cache in the next\n  // entering of this method. But do not need to clear other cache like `Style::bind`.\n  else if (cachedByMe) {\n      ctx.__attrCachedBy = ContextCachedBy.NONE;\n    }\n\n  var styleFont = style.font || DEFAULT_FONT; // PENDING\n  // Only `Text` el set `font` and keep it (`RectText` will restore). So theoretically\n  // we can make font cache on ctx, which can cache for text el that are discontinuous.\n  // But layer save/restore needed to be considered.\n  // if (styleFont !== ctx.__fontCache) {\n  //     ctx.font = styleFont;\n  //     if (prevEl !== WILL_BE_RESTORED) {\n  //         ctx.__fontCache = styleFont;\n  //     }\n  // }\n\n  if (!checkCache || styleFont !== (prevStyle.font || DEFAULT_FONT)) {\n    ctx.font = styleFont;\n  } // Use the final font from context-2d, because the final\n  // font might not be the style.font when it is illegal.\n  // But get `ctx.font` might be time consuming.\n\n\n  var computedFont = hostEl.__computedFont;\n\n  if (hostEl.__styleFont !== styleFont) {\n    hostEl.__styleFont = styleFont;\n    computedFont = hostEl.__computedFont = ctx.font;\n  }\n\n  var textPadding = style.textPadding;\n  var textLineHeight = style.textLineHeight;\n  var contentBlock = hostEl.__textCotentBlock;\n\n  if (!contentBlock || hostEl.__dirtyText) {\n    contentBlock = hostEl.__textCotentBlock = textContain.parsePlainText(text, computedFont, textPadding, textLineHeight, style.truncate);\n  }\n\n  var outerHeight = contentBlock.outerHeight;\n  var textLines = contentBlock.lines;\n  var lineHeight = contentBlock.lineHeight;\n  var boxPos = getBoxPosition(outerHeight, style, rect);\n  var baseX = boxPos.baseX;\n  var baseY = boxPos.baseY;\n  var textAlign = boxPos.textAlign || 'left';\n  var textVerticalAlign = boxPos.textVerticalAlign; // Origin of textRotation should be the base point of text drawing.\n\n  applyTextRotation(ctx, style, rect, baseX, baseY);\n  var boxY = textContain.adjustTextY(baseY, outerHeight, textVerticalAlign);\n  var textX = baseX;\n  var textY = boxY;\n\n  if (needDrawBg || textPadding) {\n    // Consider performance, do not call getTextWidth util necessary.\n    var textWidth = textContain.getWidth(text, computedFont);\n    var outerWidth = textWidth;\n    textPadding && (outerWidth += textPadding[1] + textPadding[3]);\n    var boxX = textContain.adjustTextX(baseX, outerWidth, textAlign);\n    needDrawBg && drawBackground(hostEl, ctx, style, boxX, boxY, outerWidth, outerHeight);\n\n    if (textPadding) {\n      textX = getTextXForPadding(baseX, textAlign, textPadding);\n      textY += textPadding[0];\n    }\n  } // Always set textAlign and textBase line, because it is difficute to calculate\n  // textAlign from prevEl, and we dont sure whether textAlign will be reset if\n  // font set happened.\n\n\n  ctx.textAlign = textAlign; // Force baseline to be \"middle\". Otherwise, if using \"top\", the\n  // text will offset downward a little bit in font \"Microsoft YaHei\".\n\n  ctx.textBaseline = 'middle'; // Set text opacity\n\n  ctx.globalAlpha = style.opacity || 1; // Always set shadowBlur and shadowOffset to avoid leak from displayable.\n\n  for (var i = 0; i < SHADOW_STYLE_COMMON_PROPS.length; i++) {\n    var propItem = SHADOW_STYLE_COMMON_PROPS[i];\n    var styleProp = propItem[0];\n    var ctxProp = propItem[1];\n    var val = style[styleProp];\n\n    if (!checkCache || val !== prevStyle[styleProp]) {\n      ctx[ctxProp] = fixShadow(ctx, ctxProp, val || propItem[2]);\n    }\n  } // `textBaseline` is set as 'middle'.\n\n\n  textY += lineHeight / 2;\n  var textStrokeWidth = style.textStrokeWidth;\n  var textStrokeWidthPrev = checkCache ? prevStyle.textStrokeWidth : null;\n  var strokeWidthChanged = !checkCache || textStrokeWidth !== textStrokeWidthPrev;\n  var strokeChanged = !checkCache || strokeWidthChanged || style.textStroke !== prevStyle.textStroke;\n  var textStroke = getStroke(style.textStroke, textStrokeWidth);\n  var textFill = getFill(style.textFill);\n\n  if (textStroke) {\n    if (strokeWidthChanged) {\n      ctx.lineWidth = textStrokeWidth;\n    }\n\n    if (strokeChanged) {\n      ctx.strokeStyle = textStroke;\n    }\n  }\n\n  if (textFill) {\n    if (!checkCache || style.textFill !== prevStyle.textFill) {\n      ctx.fillStyle = textFill;\n    }\n  } // Optimize simply, in most cases only one line exists.\n\n\n  if (textLines.length === 1) {\n    // Fill after stroke so the outline will not cover the main part.\n    textStroke && ctx.strokeText(textLines[0], textX, textY);\n    textFill && ctx.fillText(textLines[0], textX, textY);\n  } else {\n    for (var i = 0; i < textLines.length; i++) {\n      // Fill after stroke so the outline will not cover the main part.\n      textStroke && ctx.strokeText(textLines[i], textX, textY);\n      textFill && ctx.fillText(textLines[i], textX, textY);\n      textY += lineHeight;\n    }\n  }\n}\n\nfunction renderRichText(hostEl, ctx, text, style, rect, prevEl) {\n  // Do not do cache for rich text because of the complexity.\n  // But `RectText` this will be restored, do not need to clear other cache like `Style::bind`.\n  if (prevEl !== WILL_BE_RESTORED) {\n    ctx.__attrCachedBy = ContextCachedBy.NONE;\n  }\n\n  var contentBlock = hostEl.__textCotentBlock;\n\n  if (!contentBlock || hostEl.__dirtyText) {\n    contentBlock = hostEl.__textCotentBlock = textContain.parseRichText(text, style);\n  }\n\n  drawRichText(hostEl, ctx, contentBlock, style, rect);\n}\n\nfunction drawRichText(hostEl, ctx, contentBlock, style, rect) {\n  var contentWidth = contentBlock.width;\n  var outerWidth = contentBlock.outerWidth;\n  var outerHeight = contentBlock.outerHeight;\n  var textPadding = style.textPadding;\n  var boxPos = getBoxPosition(outerHeight, style, rect);\n  var baseX = boxPos.baseX;\n  var baseY = boxPos.baseY;\n  var textAlign = boxPos.textAlign;\n  var textVerticalAlign = boxPos.textVerticalAlign; // Origin of textRotation should be the base point of text drawing.\n\n  applyTextRotation(ctx, style, rect, baseX, baseY);\n  var boxX = textContain.adjustTextX(baseX, outerWidth, textAlign);\n  var boxY = textContain.adjustTextY(baseY, outerHeight, textVerticalAlign);\n  var xLeft = boxX;\n  var lineTop = boxY;\n\n  if (textPadding) {\n    xLeft += textPadding[3];\n    lineTop += textPadding[0];\n  }\n\n  var xRight = xLeft + contentWidth;\n  needDrawBackground(style) && drawBackground(hostEl, ctx, style, boxX, boxY, outerWidth, outerHeight);\n\n  for (var i = 0; i < contentBlock.lines.length; i++) {\n    var line = contentBlock.lines[i];\n    var tokens = line.tokens;\n    var tokenCount = tokens.length;\n    var lineHeight = line.lineHeight;\n    var usedWidth = line.width;\n    var leftIndex = 0;\n    var lineXLeft = xLeft;\n    var lineXRight = xRight;\n    var rightIndex = tokenCount - 1;\n    var token;\n\n    while (leftIndex < tokenCount && (token = tokens[leftIndex], !token.textAlign || token.textAlign === 'left')) {\n      placeToken(hostEl, ctx, token, style, lineHeight, lineTop, lineXLeft, 'left');\n      usedWidth -= token.width;\n      lineXLeft += token.width;\n      leftIndex++;\n    }\n\n    while (rightIndex >= 0 && (token = tokens[rightIndex], token.textAlign === 'right')) {\n      placeToken(hostEl, ctx, token, style, lineHeight, lineTop, lineXRight, 'right');\n      usedWidth -= token.width;\n      lineXRight -= token.width;\n      rightIndex--;\n    } // The other tokens are placed as textAlign 'center' if there is enough space.\n\n\n    lineXLeft += (contentWidth - (lineXLeft - xLeft) - (xRight - lineXRight) - usedWidth) / 2;\n\n    while (leftIndex <= rightIndex) {\n      token = tokens[leftIndex]; // Consider width specified by user, use 'center' rather than 'left'.\n\n      placeToken(hostEl, ctx, token, style, lineHeight, lineTop, lineXLeft + token.width / 2, 'center');\n      lineXLeft += token.width;\n      leftIndex++;\n    }\n\n    lineTop += lineHeight;\n  }\n}\n\nfunction applyTextRotation(ctx, style, rect, x, y) {\n  // textRotation only apply in RectText.\n  if (rect && style.textRotation) {\n    var origin = style.textOrigin;\n\n    if (origin === 'center') {\n      x = rect.width / 2 + rect.x;\n      y = rect.height / 2 + rect.y;\n    } else if (origin) {\n      x = origin[0] + rect.x;\n      y = origin[1] + rect.y;\n    }\n\n    ctx.translate(x, y); // Positive: anticlockwise\n\n    ctx.rotate(-style.textRotation);\n    ctx.translate(-x, -y);\n  }\n}\n\nfunction placeToken(hostEl, ctx, token, style, lineHeight, lineTop, x, textAlign) {\n  var tokenStyle = style.rich[token.styleName] || {};\n  tokenStyle.text = token.text; // 'ctx.textBaseline' is always set as 'middle', for sake of\n  // the bias of \"Microsoft YaHei\".\n\n  var textVerticalAlign = token.textVerticalAlign;\n  var y = lineTop + lineHeight / 2;\n\n  if (textVerticalAlign === 'top') {\n    y = lineTop + token.height / 2;\n  } else if (textVerticalAlign === 'bottom') {\n    y = lineTop + lineHeight - token.height / 2;\n  }\n\n  !token.isLineHolder && needDrawBackground(tokenStyle) && drawBackground(hostEl, ctx, tokenStyle, textAlign === 'right' ? x - token.width : textAlign === 'center' ? x - token.width / 2 : x, y - token.height / 2, token.width, token.height);\n  var textPadding = token.textPadding;\n\n  if (textPadding) {\n    x = getTextXForPadding(x, textAlign, textPadding);\n    y -= token.height / 2 - textPadding[2] - token.textHeight / 2;\n  }\n\n  setCtx(ctx, 'shadowBlur', retrieve3(tokenStyle.textShadowBlur, style.textShadowBlur, 0));\n  setCtx(ctx, 'shadowColor', tokenStyle.textShadowColor || style.textShadowColor || 'transparent');\n  setCtx(ctx, 'shadowOffsetX', retrieve3(tokenStyle.textShadowOffsetX, style.textShadowOffsetX, 0));\n  setCtx(ctx, 'shadowOffsetY', retrieve3(tokenStyle.textShadowOffsetY, style.textShadowOffsetY, 0));\n  setCtx(ctx, 'textAlign', textAlign); // Force baseline to be \"middle\". Otherwise, if using \"top\", the\n  // text will offset downward a little bit in font \"Microsoft YaHei\".\n\n  setCtx(ctx, 'textBaseline', 'middle');\n  setCtx(ctx, 'font', token.font || DEFAULT_FONT);\n  var textStroke = getStroke(tokenStyle.textStroke || style.textStroke, textStrokeWidth);\n  var textFill = getFill(tokenStyle.textFill || style.textFill);\n  var textStrokeWidth = retrieve2(tokenStyle.textStrokeWidth, style.textStrokeWidth); // Fill after stroke so the outline will not cover the main part.\n\n  if (textStroke) {\n    setCtx(ctx, 'lineWidth', textStrokeWidth);\n    setCtx(ctx, 'strokeStyle', textStroke);\n    ctx.strokeText(token.text, x, y);\n  }\n\n  if (textFill) {\n    setCtx(ctx, 'fillStyle', textFill);\n    ctx.fillText(token.text, x, y);\n  }\n}\n\nfunction needDrawBackground(style) {\n  return !!(style.textBackgroundColor || style.textBorderWidth && style.textBorderColor);\n} // style: {textBackgroundColor, textBorderWidth, textBorderColor, textBorderRadius, text}\n// shape: {x, y, width, height}\n\n\nfunction drawBackground(hostEl, ctx, style, x, y, width, height) {\n  var textBackgroundColor = style.textBackgroundColor;\n  var textBorderWidth = style.textBorderWidth;\n  var textBorderColor = style.textBorderColor;\n  var isPlainBg = isString(textBackgroundColor);\n  setCtx(ctx, 'shadowBlur', style.textBoxShadowBlur || 0);\n  setCtx(ctx, 'shadowColor', style.textBoxShadowColor || 'transparent');\n  setCtx(ctx, 'shadowOffsetX', style.textBoxShadowOffsetX || 0);\n  setCtx(ctx, 'shadowOffsetY', style.textBoxShadowOffsetY || 0);\n\n  if (isPlainBg || textBorderWidth && textBorderColor) {\n    ctx.beginPath();\n    var textBorderRadius = style.textBorderRadius;\n\n    if (!textBorderRadius) {\n      ctx.rect(x, y, width, height);\n    } else {\n      roundRectHelper.buildPath(ctx, {\n        x: x,\n        y: y,\n        width: width,\n        height: height,\n        r: textBorderRadius\n      });\n    }\n\n    ctx.closePath();\n  }\n\n  if (isPlainBg) {\n    setCtx(ctx, 'fillStyle', textBackgroundColor);\n\n    if (style.fillOpacity != null) {\n      var originalGlobalAlpha = ctx.globalAlpha;\n      ctx.globalAlpha = style.fillOpacity * style.opacity;\n      ctx.fill();\n      ctx.globalAlpha = originalGlobalAlpha;\n    } else {\n      ctx.fill();\n    }\n  } else if (isObject(textBackgroundColor)) {\n    var image = textBackgroundColor.image;\n    image = imageHelper.createOrUpdateImage(image, null, hostEl, onBgImageLoaded, textBackgroundColor);\n\n    if (image && imageHelper.isImageReady(image)) {\n      ctx.drawImage(image, x, y, width, height);\n    }\n  }\n\n  if (textBorderWidth && textBorderColor) {\n    setCtx(ctx, 'lineWidth', textBorderWidth);\n    setCtx(ctx, 'strokeStyle', textBorderColor);\n\n    if (style.strokeOpacity != null) {\n      var originalGlobalAlpha = ctx.globalAlpha;\n      ctx.globalAlpha = style.strokeOpacity * style.opacity;\n      ctx.stroke();\n      ctx.globalAlpha = originalGlobalAlpha;\n    } else {\n      ctx.stroke();\n    }\n  }\n}\n\nfunction onBgImageLoaded(image, textBackgroundColor) {\n  // Replace image, so that `contain/text.js#parseRichText`\n  // will get correct result in next tick.\n  textBackgroundColor.image = image;\n}\n\nfunction getBoxPosition(blockHeiht, style, rect) {\n  var baseX = style.x || 0;\n  var baseY = style.y || 0;\n  var textAlign = style.textAlign;\n  var textVerticalAlign = style.textVerticalAlign; // Text position represented by coord\n\n  if (rect) {\n    var textPosition = style.textPosition;\n\n    if (textPosition instanceof Array) {\n      // Percent\n      baseX = rect.x + parsePercent(textPosition[0], rect.width);\n      baseY = rect.y + parsePercent(textPosition[1], rect.height);\n    } else {\n      var res = textContain.adjustTextPositionOnRect(textPosition, rect, style.textDistance);\n      baseX = res.x;\n      baseY = res.y; // Default align and baseline when has textPosition\n\n      textAlign = textAlign || res.textAlign;\n      textVerticalAlign = textVerticalAlign || res.textVerticalAlign;\n    } // textOffset is only support in RectText, otherwise\n    // we have to adjust boundingRect for textOffset.\n\n\n    var textOffset = style.textOffset;\n\n    if (textOffset) {\n      baseX += textOffset[0];\n      baseY += textOffset[1];\n    }\n  }\n\n  return {\n    baseX: baseX,\n    baseY: baseY,\n    textAlign: textAlign,\n    textVerticalAlign: textVerticalAlign\n  };\n}\n\nfunction setCtx(ctx, prop, value) {\n  ctx[prop] = fixShadow(ctx, prop, value);\n  return ctx[prop];\n}\n/**\n * @param {string} [stroke] If specified, do not check style.textStroke.\n * @param {string} [lineWidth] If specified, do not check style.textStroke.\n * @param {number} style\n */\n\n\nfunction getStroke(stroke, lineWidth) {\n  return stroke == null || lineWidth <= 0 || stroke === 'transparent' || stroke === 'none' ? null // TODO pattern and gradient?\n  : stroke.image || stroke.colorStops ? '#000' : stroke;\n}\n\nfunction getFill(fill) {\n  return fill == null || fill === 'none' ? null // TODO pattern and gradient?\n  : fill.image || fill.colorStops ? '#000' : fill;\n}\n\nfunction parsePercent(value, maxValue) {\n  if (typeof value === 'string') {\n    if (value.lastIndexOf('%') >= 0) {\n      return parseFloat(value) / 100 * maxValue;\n    }\n\n    return parseFloat(value);\n  }\n\n  return value;\n}\n\nfunction getTextXForPadding(x, textAlign, textPadding) {\n  return textAlign === 'right' ? x - textPadding[1] : textAlign === 'center' ? x + textPadding[3] / 2 - textPadding[1] / 2 : x + textPadding[3];\n}\n/**\n * @param {string} text\n * @param {module:zrender/Style} style\n * @return {boolean}\n */\n\n\nfunction needDrawText(text, style) {\n  return text != null && (text || style.textBackgroundColor || style.textBorderWidth && style.textBorderColor || style.textPadding);\n}\n\nexports.normalizeTextStyle = normalizeTextStyle;\nexports.renderText = renderText;\nexports.getStroke = getStroke;\nexports.getFill = getFill;\nexports.needDrawText = needDrawText;\n\n/***/ }),\n/* 23 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar BoundingRect = __webpack_require__(3);\n\nvar imageHelper = __webpack_require__(11);\n\nvar _util = __webpack_require__(0);\n\nvar getContext = _util.getContext;\nvar extend = _util.extend;\nvar retrieve2 = _util.retrieve2;\nvar retrieve3 = _util.retrieve3;\nvar trim = _util.trim;\nvar textWidthCache = {};\nvar textWidthCacheCounter = 0;\nvar TEXT_CACHE_MAX = 5000;\nvar STYLE_REG = /\\{([a-zA-Z0-9_]+)\\|([^}]*)\\}/g;\nvar DEFAULT_FONT = '12px sans-serif'; // Avoid assign to an exported variable, for transforming to cjs.\n\nvar methods = {};\n\nfunction $override(name, fn) {\n  methods[name] = fn;\n}\n/**\n * @public\n * @param {string} text\n * @param {string} font\n * @return {number} width\n */\n\n\nfunction getWidth(text, font) {\n  font = font || DEFAULT_FONT;\n  var key = text + ':' + font;\n\n  if (textWidthCache[key]) {\n    return textWidthCache[key];\n  }\n\n  var textLines = (text + '').split('\\n');\n  var width = 0;\n\n  for (var i = 0, l = textLines.length; i < l; i++) {\n    // textContain.measureText may be overrided in SVG or VML\n    width = Math.max(measureText(textLines[i], font).width, width);\n  }\n\n  if (textWidthCacheCounter > TEXT_CACHE_MAX) {\n    textWidthCacheCounter = 0;\n    textWidthCache = {};\n  }\n\n  textWidthCacheCounter++;\n  textWidthCache[key] = width;\n  return width;\n}\n/**\n * @public\n * @param {string} text\n * @param {string} font\n * @param {string} [textAlign='left']\n * @param {string} [textVerticalAlign='top']\n * @param {Array.<number>} [textPadding]\n * @param {Object} [rich]\n * @param {Object} [truncate]\n * @return {Object} {x, y, width, height, lineHeight}\n */\n\n\nfunction getBoundingRect(text, font, textAlign, textVerticalAlign, textPadding, textLineHeight, rich, truncate) {\n  return rich ? getRichTextRect(text, font, textAlign, textVerticalAlign, textPadding, textLineHeight, rich, truncate) : getPlainTextRect(text, font, textAlign, textVerticalAlign, textPadding, textLineHeight, truncate);\n}\n\nfunction getPlainTextRect(text, font, textAlign, textVerticalAlign, textPadding, textLineHeight, truncate) {\n  var contentBlock = parsePlainText(text, font, textPadding, textLineHeight, truncate);\n  var outerWidth = getWidth(text, font);\n\n  if (textPadding) {\n    outerWidth += textPadding[1] + textPadding[3];\n  }\n\n  var outerHeight = contentBlock.outerHeight;\n  var x = adjustTextX(0, outerWidth, textAlign);\n  var y = adjustTextY(0, outerHeight, textVerticalAlign);\n  var rect = new BoundingRect(x, y, outerWidth, outerHeight);\n  rect.lineHeight = contentBlock.lineHeight;\n  return rect;\n}\n\nfunction getRichTextRect(text, font, textAlign, textVerticalAlign, textPadding, textLineHeight, rich, truncate) {\n  var contentBlock = parseRichText(text, {\n    rich: rich,\n    truncate: truncate,\n    font: font,\n    textAlign: textAlign,\n    textPadding: textPadding,\n    textLineHeight: textLineHeight\n  });\n  var outerWidth = contentBlock.outerWidth;\n  var outerHeight = contentBlock.outerHeight;\n  var x = adjustTextX(0, outerWidth, textAlign);\n  var y = adjustTextY(0, outerHeight, textVerticalAlign);\n  return new BoundingRect(x, y, outerWidth, outerHeight);\n}\n/**\n * @public\n * @param {number} x\n * @param {number} width\n * @param {string} [textAlign='left']\n * @return {number} Adjusted x.\n */\n\n\nfunction adjustTextX(x, width, textAlign) {\n  // FIXME Right to left language\n  if (textAlign === 'right') {\n    x -= width;\n  } else if (textAlign === 'center') {\n    x -= width / 2;\n  }\n\n  return x;\n}\n/**\n * @public\n * @param {number} y\n * @param {number} height\n * @param {string} [textVerticalAlign='top']\n * @return {number} Adjusted y.\n */\n\n\nfunction adjustTextY(y, height, textVerticalAlign) {\n  if (textVerticalAlign === 'middle') {\n    y -= height / 2;\n  } else if (textVerticalAlign === 'bottom') {\n    y -= height;\n  }\n\n  return y;\n}\n/**\n * @public\n * @param {stirng} textPosition\n * @param {Object} rect {x, y, width, height}\n * @param {number} distance\n * @return {Object} {x, y, textAlign, textVerticalAlign}\n */\n\n\nfunction adjustTextPositionOnRect(textPosition, rect, distance) {\n  var x = rect.x;\n  var y = rect.y;\n  var height = rect.height;\n  var width = rect.width;\n  var halfHeight = height / 2;\n  var textAlign = 'left';\n  var textVerticalAlign = 'top';\n\n  switch (textPosition) {\n    case 'left':\n      x -= distance;\n      y += halfHeight;\n      textAlign = 'right';\n      textVerticalAlign = 'middle';\n      break;\n\n    case 'right':\n      x += distance + width;\n      y += halfHeight;\n      textVerticalAlign = 'middle';\n      break;\n\n    case 'top':\n      x += width / 2;\n      y -= distance;\n      textAlign = 'center';\n      textVerticalAlign = 'bottom';\n      break;\n\n    case 'bottom':\n      x += width / 2;\n      y += height + distance;\n      textAlign = 'center';\n      break;\n\n    case 'inside':\n      x += width / 2;\n      y += halfHeight;\n      textAlign = 'center';\n      textVerticalAlign = 'middle';\n      break;\n\n    case 'insideLeft':\n      x += distance;\n      y += halfHeight;\n      textVerticalAlign = 'middle';\n      break;\n\n    case 'insideRight':\n      x += width - distance;\n      y += halfHeight;\n      textAlign = 'right';\n      textVerticalAlign = 'middle';\n      break;\n\n    case 'insideTop':\n      x += width / 2;\n      y += distance;\n      textAlign = 'center';\n      break;\n\n    case 'insideBottom':\n      x += width / 2;\n      y += height - distance;\n      textAlign = 'center';\n      textVerticalAlign = 'bottom';\n      break;\n\n    case 'insideTopLeft':\n      x += distance;\n      y += distance;\n      break;\n\n    case 'insideTopRight':\n      x += width - distance;\n      y += distance;\n      textAlign = 'right';\n      break;\n\n    case 'insideBottomLeft':\n      x += distance;\n      y += height - distance;\n      textVerticalAlign = 'bottom';\n      break;\n\n    case 'insideBottomRight':\n      x += width - distance;\n      y += height - distance;\n      textAlign = 'right';\n      textVerticalAlign = 'bottom';\n      break;\n  }\n\n  return {\n    x: x,\n    y: y,\n    textAlign: textAlign,\n    textVerticalAlign: textVerticalAlign\n  };\n}\n/**\n * Show ellipsis if overflow.\n *\n * @public\n * @param  {string} text\n * @param  {string} containerWidth\n * @param  {string} font\n * @param  {number} [ellipsis='...']\n * @param  {Object} [options]\n * @param  {number} [options.maxIterations=3]\n * @param  {number} [options.minChar=0] If truncate result are less\n *                  then minChar, ellipsis will not show, which is\n *                  better for user hint in some cases.\n * @param  {number} [options.placeholder=''] When all truncated, use the placeholder.\n * @return {string}\n */\n\n\nfunction truncateText(text, containerWidth, font, ellipsis, options) {\n  if (!containerWidth) {\n    return '';\n  }\n\n  var textLines = (text + '').split('\\n');\n  options = prepareTruncateOptions(containerWidth, font, ellipsis, options); // FIXME\n  // It is not appropriate that every line has '...' when truncate multiple lines.\n\n  for (var i = 0, len = textLines.length; i < len; i++) {\n    textLines[i] = truncateSingleLine(textLines[i], options);\n  }\n\n  return textLines.join('\\n');\n}\n\nfunction prepareTruncateOptions(containerWidth, font, ellipsis, options) {\n  options = extend({}, options);\n  options.font = font;\n  var ellipsis = retrieve2(ellipsis, '...');\n  options.maxIterations = retrieve2(options.maxIterations, 2);\n  var minChar = options.minChar = retrieve2(options.minChar, 0); // FIXME\n  // Other languages?\n\n  options.cnCharWidth = getWidth('国', font); // FIXME\n  // Consider proportional font?\n\n  var ascCharWidth = options.ascCharWidth = getWidth('a', font);\n  options.placeholder = retrieve2(options.placeholder, ''); // Example 1: minChar: 3, text: 'asdfzxcv', truncate result: 'asdf', but not: 'a...'.\n  // Example 2: minChar: 3, text: '维度', truncate result: '维', but not: '...'.\n\n  var contentWidth = containerWidth = Math.max(0, containerWidth - 1); // Reserve some gap.\n\n  for (var i = 0; i < minChar && contentWidth >= ascCharWidth; i++) {\n    contentWidth -= ascCharWidth;\n  }\n\n  var ellipsisWidth = getWidth(ellipsis, font);\n\n  if (ellipsisWidth > contentWidth) {\n    ellipsis = '';\n    ellipsisWidth = 0;\n  }\n\n  contentWidth = containerWidth - ellipsisWidth;\n  options.ellipsis = ellipsis;\n  options.ellipsisWidth = ellipsisWidth;\n  options.contentWidth = contentWidth;\n  options.containerWidth = containerWidth;\n  return options;\n}\n\nfunction truncateSingleLine(textLine, options) {\n  var containerWidth = options.containerWidth;\n  var font = options.font;\n  var contentWidth = options.contentWidth;\n\n  if (!containerWidth) {\n    return '';\n  }\n\n  var lineWidth = getWidth(textLine, font);\n\n  if (lineWidth <= containerWidth) {\n    return textLine;\n  }\n\n  for (var j = 0;; j++) {\n    if (lineWidth <= contentWidth || j >= options.maxIterations) {\n      textLine += options.ellipsis;\n      break;\n    }\n\n    var subLength = j === 0 ? estimateLength(textLine, contentWidth, options.ascCharWidth, options.cnCharWidth) : lineWidth > 0 ? Math.floor(textLine.length * contentWidth / lineWidth) : 0;\n    textLine = textLine.substr(0, subLength);\n    lineWidth = getWidth(textLine, font);\n  }\n\n  if (textLine === '') {\n    textLine = options.placeholder;\n  }\n\n  return textLine;\n}\n\nfunction estimateLength(text, contentWidth, ascCharWidth, cnCharWidth) {\n  var width = 0;\n  var i = 0;\n\n  for (var len = text.length; i < len && width < contentWidth; i++) {\n    var charCode = text.charCodeAt(i);\n    width += 0 <= charCode && charCode <= 127 ? ascCharWidth : cnCharWidth;\n  }\n\n  return i;\n}\n/**\n * @public\n * @param {string} font\n * @return {number} line height\n */\n\n\nfunction getLineHeight(font) {\n  // FIXME A rough approach.\n  return getWidth('国', font);\n}\n/**\n * @public\n * @param {string} text\n * @param {string} font\n * @return {Object} width\n */\n\n\nfunction measureText(text, font) {\n  return methods.measureText(text, font);\n} // Avoid assign to an exported variable, for transforming to cjs.\n\n\nmethods.measureText = function (text, font) {\n  var ctx = getContext();\n  ctx.font = font || DEFAULT_FONT;\n  return ctx.measureText(text);\n};\n/**\n * @public\n * @param {string} text\n * @param {string} font\n * @param {Object} [truncate]\n * @return {Object} block: {lineHeight, lines, height, outerHeight}\n *  Notice: for performance, do not calculate outerWidth util needed.\n */\n\n\nfunction parsePlainText(text, font, padding, textLineHeight, truncate) {\n  text != null && (text += '');\n  var lineHeight = retrieve2(textLineHeight, getLineHeight(font));\n  var lines = text ? text.split('\\n') : [];\n  var height = lines.length * lineHeight;\n  var outerHeight = height;\n\n  if (padding) {\n    outerHeight += padding[0] + padding[2];\n  }\n\n  if (text && truncate) {\n    var truncOuterHeight = truncate.outerHeight;\n    var truncOuterWidth = truncate.outerWidth;\n\n    if (truncOuterHeight != null && outerHeight > truncOuterHeight) {\n      text = '';\n      lines = [];\n    } else if (truncOuterWidth != null) {\n      var options = prepareTruncateOptions(truncOuterWidth - (padding ? padding[1] + padding[3] : 0), font, truncate.ellipsis, {\n        minChar: truncate.minChar,\n        placeholder: truncate.placeholder\n      }); // FIXME\n      // It is not appropriate that every line has '...' when truncate multiple lines.\n\n      for (var i = 0, len = lines.length; i < len; i++) {\n        lines[i] = truncateSingleLine(lines[i], options);\n      }\n    }\n  }\n\n  return {\n    lines: lines,\n    height: height,\n    outerHeight: outerHeight,\n    lineHeight: lineHeight\n  };\n}\n/**\n * For example: 'some text {a|some text}other text{b|some text}xxx{c|}xxx'\n * Also consider 'bbbb{a|xxx\\nzzz}xxxx\\naaaa'.\n *\n * @public\n * @param {string} text\n * @param {Object} style\n * @return {Object} block\n * {\n *      width,\n *      height,\n *      lines: [{\n *          lineHeight,\n *          width,\n *          tokens: [[{\n *              styleName,\n *              text,\n *              width,      // include textPadding\n *              height,     // include textPadding\n *              textWidth, // pure text width\n *              textHeight, // pure text height\n *              lineHeihgt,\n *              font,\n *              textAlign,\n *              textVerticalAlign\n *          }], [...], ...]\n *      }, ...]\n * }\n * If styleName is undefined, it is plain text.\n */\n\n\nfunction parseRichText(text, style) {\n  var contentBlock = {\n    lines: [],\n    width: 0,\n    height: 0\n  };\n  text != null && (text += '');\n\n  if (!text) {\n    return contentBlock;\n  }\n\n  var lastIndex = STYLE_REG.lastIndex = 0;\n  var result;\n\n  while ((result = STYLE_REG.exec(text)) != null) {\n    var matchedIndex = result.index;\n\n    if (matchedIndex > lastIndex) {\n      pushTokens(contentBlock, text.substring(lastIndex, matchedIndex));\n    }\n\n    pushTokens(contentBlock, result[2], result[1]);\n    lastIndex = STYLE_REG.lastIndex;\n  }\n\n  if (lastIndex < text.length) {\n    pushTokens(contentBlock, text.substring(lastIndex, text.length));\n  }\n\n  var lines = contentBlock.lines;\n  var contentHeight = 0;\n  var contentWidth = 0; // For `textWidth: 100%`\n\n  var pendingList = [];\n  var stlPadding = style.textPadding;\n  var truncate = style.truncate;\n  var truncateWidth = truncate && truncate.outerWidth;\n  var truncateHeight = truncate && truncate.outerHeight;\n\n  if (stlPadding) {\n    truncateWidth != null && (truncateWidth -= stlPadding[1] + stlPadding[3]);\n    truncateHeight != null && (truncateHeight -= stlPadding[0] + stlPadding[2]);\n  } // Calculate layout info of tokens.\n\n\n  for (var i = 0; i < lines.length; i++) {\n    var line = lines[i];\n    var lineHeight = 0;\n    var lineWidth = 0;\n\n    for (var j = 0; j < line.tokens.length; j++) {\n      var token = line.tokens[j];\n      var tokenStyle = token.styleName && style.rich[token.styleName] || {}; // textPadding should not inherit from style.\n\n      var textPadding = token.textPadding = tokenStyle.textPadding; // textFont has been asigned to font by `normalizeStyle`.\n\n      var font = token.font = tokenStyle.font || style.font; // textHeight can be used when textVerticalAlign is specified in token.\n\n      var tokenHeight = token.textHeight = retrieve2( // textHeight should not be inherited, consider it can be specified\n      // as box height of the block.\n      tokenStyle.textHeight, getLineHeight(font));\n      textPadding && (tokenHeight += textPadding[0] + textPadding[2]);\n      token.height = tokenHeight;\n      token.lineHeight = retrieve3(tokenStyle.textLineHeight, style.textLineHeight, tokenHeight);\n      token.textAlign = tokenStyle && tokenStyle.textAlign || style.textAlign;\n      token.textVerticalAlign = tokenStyle && tokenStyle.textVerticalAlign || 'middle';\n\n      if (truncateHeight != null && contentHeight + token.lineHeight > truncateHeight) {\n        return {\n          lines: [],\n          width: 0,\n          height: 0\n        };\n      }\n\n      token.textWidth = getWidth(token.text, font);\n      var tokenWidth = tokenStyle.textWidth;\n      var tokenWidthNotSpecified = tokenWidth == null || tokenWidth === 'auto'; // Percent width, can be `100%`, can be used in drawing separate\n      // line when box width is needed to be auto.\n\n      if (typeof tokenWidth === 'string' && tokenWidth.charAt(tokenWidth.length - 1) === '%') {\n        token.percentWidth = tokenWidth;\n        pendingList.push(token);\n        tokenWidth = 0; // Do not truncate in this case, because there is no user case\n        // and it is too complicated.\n      } else {\n        if (tokenWidthNotSpecified) {\n          tokenWidth = token.textWidth; // FIXME: If image is not loaded and textWidth is not specified, calling\n          // `getBoundingRect()` will not get correct result.\n\n          var textBackgroundColor = tokenStyle.textBackgroundColor;\n          var bgImg = textBackgroundColor && textBackgroundColor.image; // Use cases:\n          // (1) If image is not loaded, it will be loaded at render phase and call\n          // `dirty()` and `textBackgroundColor.image` will be replaced with the loaded\n          // image, and then the right size will be calculated here at the next tick.\n          // See `graphic/helper/text.js`.\n          // (2) If image loaded, and `textBackgroundColor.image` is image src string,\n          // use `imageHelper.findExistImage` to find cached image.\n          // `imageHelper.findExistImage` will always be called here before\n          // `imageHelper.createOrUpdateImage` in `graphic/helper/text.js#renderRichText`\n          // which ensures that image will not be rendered before correct size calcualted.\n\n          if (bgImg) {\n            bgImg = imageHelper.findExistImage(bgImg);\n\n            if (imageHelper.isImageReady(bgImg)) {\n              tokenWidth = Math.max(tokenWidth, bgImg.width * tokenHeight / bgImg.height);\n            }\n          }\n        }\n\n        var paddingW = textPadding ? textPadding[1] + textPadding[3] : 0;\n        tokenWidth += paddingW;\n        var remianTruncWidth = truncateWidth != null ? truncateWidth - lineWidth : null;\n\n        if (remianTruncWidth != null && remianTruncWidth < tokenWidth) {\n          if (!tokenWidthNotSpecified || remianTruncWidth < paddingW) {\n            token.text = '';\n            token.textWidth = tokenWidth = 0;\n          } else {\n            token.text = truncateText(token.text, remianTruncWidth - paddingW, font, truncate.ellipsis, {\n              minChar: truncate.minChar\n            });\n            token.textWidth = getWidth(token.text, font);\n            tokenWidth = token.textWidth + paddingW;\n          }\n        }\n      }\n\n      lineWidth += token.width = tokenWidth;\n      tokenStyle && (lineHeight = Math.max(lineHeight, token.lineHeight));\n    }\n\n    line.width = lineWidth;\n    line.lineHeight = lineHeight;\n    contentHeight += lineHeight;\n    contentWidth = Math.max(contentWidth, lineWidth);\n  }\n\n  contentBlock.outerWidth = contentBlock.width = retrieve2(style.textWidth, contentWidth);\n  contentBlock.outerHeight = contentBlock.height = retrieve2(style.textHeight, contentHeight);\n\n  if (stlPadding) {\n    contentBlock.outerWidth += stlPadding[1] + stlPadding[3];\n    contentBlock.outerHeight += stlPadding[0] + stlPadding[2];\n  }\n\n  for (var i = 0; i < pendingList.length; i++) {\n    var token = pendingList[i];\n    var percentWidth = token.percentWidth; // Should not base on outerWidth, because token can not be placed out of padding.\n\n    token.width = parseInt(percentWidth, 10) / 100 * contentWidth;\n  }\n\n  return contentBlock;\n}\n\nfunction pushTokens(block, str, styleName) {\n  var isEmptyStr = str === '';\n  var strs = str.split('\\n');\n  var lines = block.lines;\n\n  for (var i = 0; i < strs.length; i++) {\n    var text = strs[i];\n    var token = {\n      styleName: styleName,\n      text: text,\n      isLineHolder: !text && !isEmptyStr\n    }; // The first token should be appended to the last line.\n\n    if (!i) {\n      var tokens = (lines[lines.length - 1] || (lines[0] = {\n        tokens: []\n      })).tokens; // Consider cases:\n      // (1) ''.split('\\n') => ['', '\\n', ''], the '' at the first item\n      // (which is a placeholder) should be replaced by new token.\n      // (2) A image backage, where token likes {a|}.\n      // (3) A redundant '' will affect textAlign in line.\n      // (4) tokens with the same tplName should not be merged, because\n      // they should be displayed in different box (with border and padding).\n\n      var tokensLen = tokens.length;\n      tokensLen === 1 && tokens[0].isLineHolder ? tokens[0] = token : // Consider text is '', only insert when it is the \"lineHolder\" or\n      // \"emptyStr\". Otherwise a redundant '' will affect textAlign in line.\n      (text || !tokensLen || isEmptyStr) && tokens.push(token);\n    } // Other tokens always start a new line.\n    else {\n        // If there is '', insert it as a placeholder.\n        lines.push({\n          tokens: [token]\n        });\n      }\n  }\n}\n\nfunction makeFont(style) {\n  // FIXME in node-canvas fontWeight is before fontStyle\n  // Use `fontSize` `fontFamily` to check whether font properties are defined.\n  var font = (style.fontSize || style.fontFamily) && [style.fontStyle, style.fontWeight, (style.fontSize || 12) + 'px', // If font properties are defined, `fontFamily` should not be ignored.\n  style.fontFamily || 'sans-serif'].join(' ');\n  return font && trim(font) || style.textFont || style.font;\n}\n\nexports.DEFAULT_FONT = DEFAULT_FONT;\nexports.$override = $override;\nexports.getWidth = getWidth;\nexports.getBoundingRect = getBoundingRect;\nexports.adjustTextX = adjustTextX;\nexports.adjustTextY = adjustTextY;\nexports.adjustTextPositionOnRect = adjustTextPositionOnRect;\nexports.truncateText = truncateText;\nexports.getLineHeight = getLineHeight;\nexports.measureText = measureText;\nexports.parsePlainText = parsePlainText;\nexports.parseRichText = parseRichText;\nexports.makeFont = makeFont;\n\n/***/ }),\n/* 24 */\n/***/ (function(module, exports) {\n\n/**\n * @param {Object} ctx\n * @param {Object} shape\n * @param {number} shape.x\n * @param {number} shape.y\n * @param {number} shape.width\n * @param {number} shape.height\n * @param {number} shape.r\n */\nfunction buildPath(ctx, shape) {\n  var x = shape.x;\n  var y = shape.y;\n  var width = shape.width;\n  var height = shape.height;\n  var r = shape.r;\n  var r1;\n  var r2;\n  var r3;\n  var r4; // Convert width and height to positive for better borderRadius\n\n  if (width < 0) {\n    x = x + width;\n    width = -width;\n  }\n\n  if (height < 0) {\n    y = y + height;\n    height = -height;\n  }\n\n  if (typeof r === 'number') {\n    r1 = r2 = r3 = r4 = r;\n  } else if (r instanceof Array) {\n    if (r.length === 1) {\n      r1 = r2 = r3 = r4 = r[0];\n    } else if (r.length === 2) {\n      r1 = r3 = r[0];\n      r2 = r4 = r[1];\n    } else if (r.length === 3) {\n      r1 = r[0];\n      r2 = r4 = r[1];\n      r3 = r[2];\n    } else {\n      r1 = r[0];\n      r2 = r[1];\n      r3 = r[2];\n      r4 = r[3];\n    }\n  } else {\n    r1 = r2 = r3 = r4 = 0;\n  }\n\n  var total;\n\n  if (r1 + r2 > width) {\n    total = r1 + r2;\n    r1 *= width / total;\n    r2 *= width / total;\n  }\n\n  if (r3 + r4 > width) {\n    total = r3 + r4;\n    r3 *= width / total;\n    r4 *= width / total;\n  }\n\n  if (r2 + r3 > height) {\n    total = r2 + r3;\n    r2 *= height / total;\n    r3 *= height / total;\n  }\n\n  if (r1 + r4 > height) {\n    total = r1 + r4;\n    r1 *= height / total;\n    r4 *= height / total;\n  }\n\n  ctx.moveTo(x + r1, y);\n  ctx.lineTo(x + width - r2, y);\n  r2 !== 0 && ctx.arc(x + width - r2, y + r2, r2, -Math.PI / 2, 0);\n  ctx.lineTo(x + width, y + height - r3);\n  r3 !== 0 && ctx.arc(x + width - r3, y + height - r3, r3, 0, Math.PI / 2);\n  ctx.lineTo(x + r4, y + height);\n  r4 !== 0 && ctx.arc(x + r4, y + height - r4, r4, Math.PI / 2, Math.PI);\n  ctx.lineTo(x, y + r1);\n  r1 !== 0 && ctx.arc(x + r1, y + r1, r1, Math.PI, Math.PI * 1.5);\n}\n\nexports.buildPath = buildPath;\n\n/***/ }),\n/* 25 */\n/***/ (function(module, exports) {\n\nvar PI2 = Math.PI * 2;\n\nfunction normalizeRadian(angle) {\n  angle %= PI2;\n\n  if (angle < 0) {\n    angle += PI2;\n  }\n\n  return angle;\n}\n\nexports.normalizeRadian = normalizeRadian;\n\n/***/ }),\n/* 26 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar smoothSpline = __webpack_require__(68);\n\nvar smoothBezier = __webpack_require__(69);\n\nfunction buildPath(ctx, shape, closePath) {\n  var points = shape.points;\n  var smooth = shape.smooth;\n\n  if (points && points.length >= 2) {\n    if (smooth && smooth !== 'spline') {\n      var controlPoints = smoothBezier(points, smooth, closePath, shape.smoothConstraint);\n      ctx.moveTo(points[0][0], points[0][1]);\n      var len = points.length;\n\n      for (var i = 0; i < (closePath ? len : len - 1); i++) {\n        var cp1 = controlPoints[i * 2];\n        var cp2 = controlPoints[i * 2 + 1];\n        var p = points[(i + 1) % len];\n        ctx.bezierCurveTo(cp1[0], cp1[1], cp2[0], cp2[1], p[0], p[1]);\n      }\n    } else {\n      if (smooth === 'spline') {\n        points = smoothSpline(points, closePath);\n      }\n\n      ctx.moveTo(points[0][0], points[0][1]);\n\n      for (var i = 1, l = points.length; i < l; i++) {\n        ctx.lineTo(points[i][0], points[i][1]);\n      }\n    }\n\n    closePath && ctx.closePath();\n  }\n}\n\nexports.buildPath = buildPath;\n\n/***/ }),\n/* 27 */\n/***/ (function(module, exports) {\n\n/**\n * Sub-pixel optimize for canvas rendering, prevent from blur\n * when rendering a thin vertical/horizontal line.\n */\nvar round = Math.round;\n/**\n * Sub pixel optimize line for canvas\n *\n * @param {Object} outputShape The modification will be performed on `outputShape`.\n *                 `outputShape` and `inputShape` can be the same object.\n *                 `outputShape` object can be used repeatly, because all of\n *                 the `x1`, `x2`, `y1`, `y2` will be assigned in this method.\n * @param {Object} [inputShape]\n * @param {number} [inputShape.x1]\n * @param {number} [inputShape.y1]\n * @param {number} [inputShape.x2]\n * @param {number} [inputShape.y2]\n * @param {Object} [style]\n * @param {number} [style.lineWidth]\n */\n\nfunction subPixelOptimizeLine(outputShape, inputShape, style) {\n  var lineWidth = style && style.lineWidth;\n\n  if (!inputShape || !lineWidth) {\n    return;\n  }\n\n  var x1 = inputShape.x1;\n  var x2 = inputShape.x2;\n  var y1 = inputShape.y1;\n  var y2 = inputShape.y2;\n\n  if (round(x1 * 2) === round(x2 * 2)) {\n    outputShape.x1 = outputShape.x2 = subPixelOptimize(x1, lineWidth, true);\n  } else {\n    outputShape.x1 = x1;\n    outputShape.x2 = x2;\n  }\n\n  if (round(y1 * 2) === round(y2 * 2)) {\n    outputShape.y1 = outputShape.y2 = subPixelOptimize(y1, lineWidth, true);\n  } else {\n    outputShape.y1 = y1;\n    outputShape.y2 = y2;\n  }\n}\n/**\n * Sub pixel optimize rect for canvas\n *\n * @param {Object} outputShape The modification will be performed on `outputShape`.\n *                 `outputShape` and `inputShape` can be the same object.\n *                 `outputShape` object can be used repeatly, because all of\n *                 the `x`, `y`, `width`, `height` will be assigned in this method.\n * @param {Object} [inputShape]\n * @param {number} [inputShape.x]\n * @param {number} [inputShape.y]\n * @param {number} [inputShape.width]\n * @param {number} [inputShape.height]\n * @param {Object} [style]\n * @param {number} [style.lineWidth]\n */\n\n\nfunction subPixelOptimizeRect(outputShape, inputShape, style) {\n  var lineWidth = style && style.lineWidth;\n\n  if (!inputShape || !lineWidth) {\n    return;\n  }\n\n  var originX = inputShape.x;\n  var originY = inputShape.y;\n  var originWidth = inputShape.width;\n  var originHeight = inputShape.height;\n  outputShape.x = subPixelOptimize(originX, lineWidth, true);\n  outputShape.y = subPixelOptimize(originY, lineWidth, true);\n  outputShape.width = Math.max(subPixelOptimize(originX + originWidth, lineWidth, false) - outputShape.x, originWidth === 0 ? 0 : 1);\n  outputShape.height = Math.max(subPixelOptimize(originY + originHeight, lineWidth, false) - outputShape.y, originHeight === 0 ? 0 : 1);\n}\n/**\n * Sub pixel optimize for canvas\n *\n * @param {number} position Coordinate, such as x, y\n * @param {number} lineWidth Should be nonnegative integer.\n * @param {boolean=} positiveOrNegative Default false (negative).\n * @return {number} Optimized position.\n */\n\n\nfunction subPixelOptimize(position, lineWidth, positiveOrNegative) {\n  // Assure that (position + lineWidth / 2) is near integer edge,\n  // otherwise line will be fuzzy in canvas.\n  var doubledPosition = round(position * 2);\n  return (doubledPosition + round(lineWidth)) % 2 === 0 ? doubledPosition / 2 : (doubledPosition + (positiveOrNegative ? 1 : -1)) / 2;\n}\n\nexports.subPixelOptimizeLine = subPixelOptimizeLine;\nexports.subPixelOptimizeRect = subPixelOptimizeRect;\nexports.subPixelOptimize = subPixelOptimize;\n\n/***/ }),\n/* 28 */\n/***/ (function(module, exports) {\n\n/**\n * @param {Array.<Object>} colorStops\n */\nvar Gradient = function (colorStops) {\n  this.colorStops = colorStops || [];\n};\n\nGradient.prototype = {\n  constructor: Gradient,\n  addColorStop: function (offset, color) {\n    this.colorStops.push({\n      offset: offset,\n      color: color\n    });\n  }\n};\nvar _default = Gradient;\nmodule.exports = _default;\n\n/***/ }),\n/* 29 */\n/***/ (function(module, exports, __webpack_require__) {\n\nmodule.exports = __webpack_require__(30);\n\n\n/***/ }),\n/* 30 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar echarts = __webpack_require__(5);\n\n__webpack_require__(31);\n__webpack_require__(38);\n\n\necharts.registerVisual(\n    echarts.util.curry(\n        __webpack_require__(80), 'liquidFill'\n    )\n);\n\n\n/***/ }),\n/* 31 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar completeDimensions = __webpack_require__(32);\nvar echarts = __webpack_require__(5);\n\necharts.extendSeriesModel({\n\n    type: 'series.liquidFill',\n\n    visualColorAccessPath: 'textStyle.normal.color',\n\n    optionUpdated: function () {\n        var option = this.option;\n        option.gridSize = Math.max(Math.floor(option.gridSize), 4);\n    },\n\n    getInitialData: function (option, ecModel) {\n        var dimensions = completeDimensions(['value'], option.data);\n        var list = new echarts.List(dimensions, this);\n        list.initData(option.data);\n        return list;\n    },\n\n    defaultOption: {\n        color: ['#294D99', '#156ACF', '#1598ED', '#45BDFF'],\n        center: ['50%', '50%'],\n        radius: '50%',\n        amplitude: '8%',\n        waveLength: '80%',\n        phase: 'auto',\n        period: 'auto',\n        direction: 'right',\n        shape: 'circle',\n\n        waveAnimation: true,\n        animationEasing: 'linear',\n        animationEasingUpdate: 'linear',\n        animationDuration: 2000,\n        animationDurationUpdate: 1000,\n\n        outline: {\n            show: true,\n            borderDistance: 8,\n            itemStyle: {\n                color: 'none',\n                borderColor: '#294D99',\n                borderWidth: 8,\n                shadowBlur: 20,\n                shadowColor: 'rgba(0, 0, 0, 0.25)'\n            }\n        },\n\n        backgroundStyle: {\n            color: '#E3F7FF'\n        },\n\n        itemStyle: {\n            opacity: 0.95,\n            shadowBlur: 50,\n            shadowColor: 'rgba(0, 0, 0, 0.4)'\n        },\n\n        label: {\n            show: true,\n            color: '#294D99',\n            insideColor: '#fff',\n            fontSize: 50,\n            fontWeight: 'bold',\n\n            align: 'center',\n            baseline: 'middle',\n            position: 'inside'\n        },\n\n        emphasis: {\n            itemStyle: {\n                opacity: 0.8\n            }\n        }\n    }\n});\n\n\n/***/ }),\n/* 32 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar _util = __webpack_require__(0);\n\nvar createHashMap = _util.createHashMap;\nvar each = _util.each;\nvar isString = _util.isString;\nvar defaults = _util.defaults;\nvar extend = _util.extend;\nvar isObject = _util.isObject;\nvar clone = _util.clone;\n\nvar _model = __webpack_require__(12);\n\nvar normalizeToArray = _model.normalizeToArray;\n\nvar _sourceHelper = __webpack_require__(33);\n\nvar guessOrdinal = _sourceHelper.guessOrdinal;\n\nvar Source = __webpack_require__(14);\n\nvar _dimensionHelper = __webpack_require__(37);\n\nvar OTHER_DIMENSIONS = _dimensionHelper.OTHER_DIMENSIONS;\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n/**\n * @deprecated\n * Use `echarts/data/helper/createDimensions` instead.\n */\n\n/**\n * @see {module:echarts/test/ut/spec/data/completeDimensions}\n *\n * Complete the dimensions array, by user defined `dimension` and `encode`,\n * and guessing from the data structure.\n * If no 'value' dimension specified, the first no-named dimension will be\n * named as 'value'.\n *\n * @param {Array.<string>} sysDims Necessary dimensions, like ['x', 'y'], which\n *      provides not only dim template, but also default order.\n *      properties: 'name', 'type', 'displayName'.\n *      `name` of each item provides default coord name.\n *      [{dimsDef: [string|Object, ...]}, ...] dimsDef of sysDim item provides default dim name, and\n *                                    provide dims count that the sysDim required.\n *      [{ordinalMeta}] can be specified.\n * @param {module:echarts/data/Source|Array|Object} source or data (for compatibal with pervious)\n * @param {Object} [opt]\n * @param {Array.<Object|string>} [opt.dimsDef] option.series.dimensions User defined dimensions\n *      For example: ['asdf', {name, type}, ...].\n * @param {Object|HashMap} [opt.encodeDef] option.series.encode {x: 2, y: [3, 1], tooltip: [1, 2], label: 3}\n * @param {string} [opt.generateCoord] Generate coord dim with the given name.\n *                 If not specified, extra dim names will be:\n *                 'value', 'value0', 'value1', ...\n * @param {number} [opt.generateCoordCount] By default, the generated dim name is `generateCoord`.\n *                 If `generateCoordCount` specified, the generated dim names will be:\n *                 `generateCoord` + 0, `generateCoord` + 1, ...\n *                 can be Infinity, indicate that use all of the remain columns.\n * @param {number} [opt.dimCount] If not specified, guess by the first data item.\n * @param {number} [opt.encodeDefaulter] If not specified, auto find the next available data dim.\n * @return {Array.<Object>} [{\n *      name: string mandatory,\n *      displayName: string, the origin name in dimsDef, see source helper.\n *                 If displayName given, the tooltip will displayed vertically.\n *      coordDim: string mandatory,\n *      coordDimIndex: number mandatory,\n *      type: string optional,\n *      otherDims: { never null/undefined\n *          tooltip: number optional,\n *          label: number optional,\n *          itemName: number optional,\n *          seriesName: number optional,\n *      },\n *      isExtraCoord: boolean true if coord is generated\n *          (not specified in encode and not series specified)\n *      other props ...\n * }]\n */\nfunction completeDimensions(sysDims, source, opt) {\n  if (!Source.isInstance(source)) {\n    source = Source.seriesDataToSource(source);\n  }\n\n  opt = opt || {};\n  sysDims = (sysDims || []).slice();\n  var dimsDef = (opt.dimsDef || []).slice();\n  var encodeDef = createHashMap(opt.encodeDef);\n  var dataDimNameMap = createHashMap();\n  var coordDimNameMap = createHashMap(); // var valueCandidate;\n\n  var result = [];\n  var dimCount = getDimCount(source, sysDims, dimsDef, opt.dimCount); // Apply user defined dims (`name` and `type`) and init result.\n\n  for (var i = 0; i < dimCount; i++) {\n    var dimDefItem = dimsDef[i] = extend({}, isObject(dimsDef[i]) ? dimsDef[i] : {\n      name: dimsDef[i]\n    });\n    var userDimName = dimDefItem.name;\n    var resultItem = result[i] = {\n      otherDims: {}\n    }; // Name will be applied later for avoiding duplication.\n\n    if (userDimName != null && dataDimNameMap.get(userDimName) == null) {\n      // Only if `series.dimensions` is defined in option\n      // displayName, will be set, and dimension will be diplayed vertically in\n      // tooltip by default.\n      resultItem.name = resultItem.displayName = userDimName;\n      dataDimNameMap.set(userDimName, i);\n    }\n\n    dimDefItem.type != null && (resultItem.type = dimDefItem.type);\n    dimDefItem.displayName != null && (resultItem.displayName = dimDefItem.displayName);\n  } // Set `coordDim` and `coordDimIndex` by `encodeDef` and normalize `encodeDef`.\n\n\n  encodeDef.each(function (dataDims, coordDim) {\n    dataDims = normalizeToArray(dataDims).slice(); // Note: It is allowed that `dataDims.length` is `0`, e.g., options is\n    // `{encode: {x: -1, y: 1}}`. Should not filter anything in\n    // this case.\n\n    if (dataDims.length === 1 && dataDims[0] < 0) {\n      encodeDef.set(coordDim, false);\n      return;\n    }\n\n    var validDataDims = encodeDef.set(coordDim, []);\n    each(dataDims, function (resultDimIdx, idx) {\n      // The input resultDimIdx can be dim name or index.\n      isString(resultDimIdx) && (resultDimIdx = dataDimNameMap.get(resultDimIdx));\n\n      if (resultDimIdx != null && resultDimIdx < dimCount) {\n        validDataDims[idx] = resultDimIdx;\n        applyDim(result[resultDimIdx], coordDim, idx);\n      }\n    });\n  }); // Apply templetes and default order from `sysDims`.\n\n  var availDimIdx = 0;\n  each(sysDims, function (sysDimItem, sysDimIndex) {\n    var coordDim;\n    var sysDimItem;\n    var sysDimItemDimsDef;\n    var sysDimItemOtherDims;\n\n    if (isString(sysDimItem)) {\n      coordDim = sysDimItem;\n      sysDimItem = {};\n    } else {\n      coordDim = sysDimItem.name;\n      var ordinalMeta = sysDimItem.ordinalMeta;\n      sysDimItem.ordinalMeta = null;\n      sysDimItem = clone(sysDimItem);\n      sysDimItem.ordinalMeta = ordinalMeta; // `coordDimIndex` should not be set directly.\n\n      sysDimItemDimsDef = sysDimItem.dimsDef;\n      sysDimItemOtherDims = sysDimItem.otherDims;\n      sysDimItem.name = sysDimItem.coordDim = sysDimItem.coordDimIndex = sysDimItem.dimsDef = sysDimItem.otherDims = null;\n    }\n\n    var dataDims = encodeDef.get(coordDim); // negative resultDimIdx means no need to mapping.\n\n    if (dataDims === false) {\n      return;\n    }\n\n    var dataDims = normalizeToArray(dataDims); // dimensions provides default dim sequences.\n\n    if (!dataDims.length) {\n      for (var i = 0; i < (sysDimItemDimsDef && sysDimItemDimsDef.length || 1); i++) {\n        while (availDimIdx < result.length && result[availDimIdx].coordDim != null) {\n          availDimIdx++;\n        }\n\n        availDimIdx < result.length && dataDims.push(availDimIdx++);\n      }\n    } // Apply templates.\n\n\n    each(dataDims, function (resultDimIdx, coordDimIndex) {\n      var resultItem = result[resultDimIdx];\n      applyDim(defaults(resultItem, sysDimItem), coordDim, coordDimIndex);\n\n      if (resultItem.name == null && sysDimItemDimsDef) {\n        var sysDimItemDimsDefItem = sysDimItemDimsDef[coordDimIndex];\n        !isObject(sysDimItemDimsDefItem) && (sysDimItemDimsDefItem = {\n          name: sysDimItemDimsDefItem\n        });\n        resultItem.name = resultItem.displayName = sysDimItemDimsDefItem.name;\n        resultItem.defaultTooltip = sysDimItemDimsDefItem.defaultTooltip;\n      } // FIXME refactor, currently only used in case: {otherDims: {tooltip: false}}\n\n\n      sysDimItemOtherDims && defaults(resultItem.otherDims, sysDimItemOtherDims);\n    });\n  });\n\n  function applyDim(resultItem, coordDim, coordDimIndex) {\n    if (OTHER_DIMENSIONS.get(coordDim) != null) {\n      resultItem.otherDims[coordDim] = coordDimIndex;\n    } else {\n      resultItem.coordDim = coordDim;\n      resultItem.coordDimIndex = coordDimIndex;\n      coordDimNameMap.set(coordDim, true);\n    }\n  } // Make sure the first extra dim is 'value'.\n\n\n  var generateCoord = opt.generateCoord;\n  var generateCoordCount = opt.generateCoordCount;\n  var fromZero = generateCoordCount != null;\n  generateCoordCount = generateCoord ? generateCoordCount || 1 : 0;\n  var extra = generateCoord || 'value'; // Set dim `name` and other `coordDim` and other props.\n\n  for (var resultDimIdx = 0; resultDimIdx < dimCount; resultDimIdx++) {\n    var resultItem = result[resultDimIdx] = result[resultDimIdx] || {};\n    var coordDim = resultItem.coordDim;\n\n    if (coordDim == null) {\n      resultItem.coordDim = genName(extra, coordDimNameMap, fromZero);\n      resultItem.coordDimIndex = 0;\n\n      if (!generateCoord || generateCoordCount <= 0) {\n        resultItem.isExtraCoord = true;\n      }\n\n      generateCoordCount--;\n    }\n\n    resultItem.name == null && (resultItem.name = genName(resultItem.coordDim, dataDimNameMap));\n\n    if (resultItem.type == null && guessOrdinal(source, resultDimIdx, resultItem.name)) {\n      resultItem.type = 'ordinal';\n    }\n  }\n\n  return result;\n} // ??? TODO\n// Originally detect dimCount by data[0]. Should we\n// optimize it to only by sysDims and dimensions and encode.\n// So only necessary dims will be initialized.\n// But\n// (1) custom series should be considered. where other dims\n// may be visited.\n// (2) sometimes user need to calcualte bubble size or use visualMap\n// on other dimensions besides coordSys needed.\n// So, dims that is not used by system, should be shared in storage?\n\n\nfunction getDimCount(source, sysDims, dimsDef, optDimCount) {\n  // Note that the result dimCount should not small than columns count\n  // of data, otherwise `dataDimNameMap` checking will be incorrect.\n  var dimCount = Math.max(source.dimensionsDetectCount || 1, sysDims.length, dimsDef.length, optDimCount || 0);\n  each(sysDims, function (sysDimItem) {\n    var sysDimItemDimsDef = sysDimItem.dimsDef;\n    sysDimItemDimsDef && (dimCount = Math.max(dimCount, sysDimItemDimsDef.length));\n  });\n  return dimCount;\n}\n\nfunction genName(name, map, fromZero) {\n  if (fromZero || map.get(name) != null) {\n    var i = 0;\n\n    while (map.get(name + i) != null) {\n      i++;\n    }\n\n    name += i;\n  }\n\n  map.set(name, true);\n  return name;\n}\n\nvar _default = completeDimensions;\nmodule.exports = _default;\n\n/***/ }),\n/* 33 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar _config = __webpack_require__(6);\n\nvar __DEV__ = _config.__DEV__;\n\nvar _model = __webpack_require__(12);\n\nvar makeInner = _model.makeInner;\nvar getDataItemValue = _model.getDataItemValue;\n\nvar _referHelper = __webpack_require__(35);\n\nvar getCoordSysDefineBySeries = _referHelper.getCoordSysDefineBySeries;\n\nvar _util = __webpack_require__(0);\n\nvar createHashMap = _util.createHashMap;\nvar each = _util.each;\nvar map = _util.map;\nvar isArray = _util.isArray;\nvar isString = _util.isString;\nvar isObject = _util.isObject;\nvar isTypedArray = _util.isTypedArray;\nvar isArrayLike = _util.isArrayLike;\nvar extend = _util.extend;\nvar assert = _util.assert;\n\nvar Source = __webpack_require__(14);\n\nvar _sourceType = __webpack_require__(15);\n\nvar SOURCE_FORMAT_ORIGINAL = _sourceType.SOURCE_FORMAT_ORIGINAL;\nvar SOURCE_FORMAT_ARRAY_ROWS = _sourceType.SOURCE_FORMAT_ARRAY_ROWS;\nvar SOURCE_FORMAT_OBJECT_ROWS = _sourceType.SOURCE_FORMAT_OBJECT_ROWS;\nvar SOURCE_FORMAT_KEYED_COLUMNS = _sourceType.SOURCE_FORMAT_KEYED_COLUMNS;\nvar SOURCE_FORMAT_UNKNOWN = _sourceType.SOURCE_FORMAT_UNKNOWN;\nvar SOURCE_FORMAT_TYPED_ARRAY = _sourceType.SOURCE_FORMAT_TYPED_ARRAY;\nvar SERIES_LAYOUT_BY_ROW = _sourceType.SERIES_LAYOUT_BY_ROW;\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\nvar inner = makeInner();\n/**\n * @see {module:echarts/data/Source}\n * @param {module:echarts/component/dataset/DatasetModel} datasetModel\n * @return {string} sourceFormat\n */\n\nfunction detectSourceFormat(datasetModel) {\n  var data = datasetModel.option.source;\n  var sourceFormat = SOURCE_FORMAT_UNKNOWN;\n\n  if (isTypedArray(data)) {\n    sourceFormat = SOURCE_FORMAT_TYPED_ARRAY;\n  } else if (isArray(data)) {\n    // FIXME Whether tolerate null in top level array?\n    if (data.length === 0) {\n      sourceFormat = SOURCE_FORMAT_ARRAY_ROWS;\n    }\n\n    for (var i = 0, len = data.length; i < len; i++) {\n      var item = data[i];\n\n      if (item == null) {\n        continue;\n      } else if (isArray(item)) {\n        sourceFormat = SOURCE_FORMAT_ARRAY_ROWS;\n        break;\n      } else if (isObject(item)) {\n        sourceFormat = SOURCE_FORMAT_OBJECT_ROWS;\n        break;\n      }\n    }\n  } else if (isObject(data)) {\n    for (var key in data) {\n      if (data.hasOwnProperty(key) && isArrayLike(data[key])) {\n        sourceFormat = SOURCE_FORMAT_KEYED_COLUMNS;\n        break;\n      }\n    }\n  } else if (data != null) {\n    throw new Error('Invalid data');\n  }\n\n  inner(datasetModel).sourceFormat = sourceFormat;\n}\n/**\n * [Scenarios]:\n * (1) Provide source data directly:\n *     series: {\n *         encode: {...},\n *         dimensions: [...]\n *         seriesLayoutBy: 'row',\n *         data: [[...]]\n *     }\n * (2) Refer to datasetModel.\n *     series: [{\n *         encode: {...}\n *         // Ignore datasetIndex means `datasetIndex: 0`\n *         // and the dimensions defination in dataset is used\n *     }, {\n *         encode: {...},\n *         seriesLayoutBy: 'column',\n *         datasetIndex: 1\n *     }]\n *\n * Get data from series itself or datset.\n * @return {module:echarts/data/Source} source\n */\n\n\nfunction getSource(seriesModel) {\n  return inner(seriesModel).source;\n}\n/**\n * MUST be called before mergeOption of all series.\n * @param {module:echarts/model/Global} ecModel\n */\n\n\nfunction resetSourceDefaulter(ecModel) {\n  // `datasetMap` is used to make default encode.\n  inner(ecModel).datasetMap = createHashMap();\n}\n/**\n * [Caution]:\n * MUST be called after series option merged and\n * before \"series.getInitailData()\" called.\n *\n * [The rule of making default encode]:\n * Category axis (if exists) alway map to the first dimension.\n * Each other axis occupies a subsequent dimension.\n *\n * [Why make default encode]:\n * Simplify the typing of encode in option, avoiding the case like that:\n * series: [{encode: {x: 0, y: 1}}, {encode: {x: 0, y: 2}}, {encode: {x: 0, y: 3}}],\n * where the \"y\" have to be manually typed as \"1, 2, 3, ...\".\n *\n * @param {module:echarts/model/Series} seriesModel\n */\n\n\nfunction prepareSource(seriesModel) {\n  var seriesOption = seriesModel.option;\n  var data = seriesOption.data;\n  var sourceFormat = isTypedArray(data) ? SOURCE_FORMAT_TYPED_ARRAY : SOURCE_FORMAT_ORIGINAL;\n  var fromDataset = false;\n  var seriesLayoutBy = seriesOption.seriesLayoutBy;\n  var sourceHeader = seriesOption.sourceHeader;\n  var dimensionsDefine = seriesOption.dimensions;\n  var datasetModel = getDatasetModel(seriesModel);\n\n  if (datasetModel) {\n    var datasetOption = datasetModel.option;\n    data = datasetOption.source;\n    sourceFormat = inner(datasetModel).sourceFormat;\n    fromDataset = true; // These settings from series has higher priority.\n\n    seriesLayoutBy = seriesLayoutBy || datasetOption.seriesLayoutBy;\n    sourceHeader == null && (sourceHeader = datasetOption.sourceHeader);\n    dimensionsDefine = dimensionsDefine || datasetOption.dimensions;\n  }\n\n  var completeResult = completeBySourceData(data, sourceFormat, seriesLayoutBy, sourceHeader, dimensionsDefine); // Note: dataset option does not have `encode`.\n\n  var encodeDefine = seriesOption.encode;\n\n  if (!encodeDefine && datasetModel) {\n    encodeDefine = makeDefaultEncode(seriesModel, datasetModel, data, sourceFormat, seriesLayoutBy, completeResult);\n  }\n\n  inner(seriesModel).source = new Source({\n    data: data,\n    fromDataset: fromDataset,\n    seriesLayoutBy: seriesLayoutBy,\n    sourceFormat: sourceFormat,\n    dimensionsDefine: completeResult.dimensionsDefine,\n    startIndex: completeResult.startIndex,\n    dimensionsDetectCount: completeResult.dimensionsDetectCount,\n    encodeDefine: encodeDefine\n  });\n} // return {startIndex, dimensionsDefine, dimensionsCount}\n\n\nfunction completeBySourceData(data, sourceFormat, seriesLayoutBy, sourceHeader, dimensionsDefine) {\n  if (!data) {\n    return {\n      dimensionsDefine: normalizeDimensionsDefine(dimensionsDefine)\n    };\n  }\n\n  var dimensionsDetectCount;\n  var startIndex;\n  var findPotentialName;\n\n  if (sourceFormat === SOURCE_FORMAT_ARRAY_ROWS) {\n    // Rule: Most of the first line are string: it is header.\n    // Caution: consider a line with 5 string and 1 number,\n    // it still can not be sure it is a head, because the\n    // 5 string may be 5 values of category columns.\n    if (sourceHeader === 'auto' || sourceHeader == null) {\n      arrayRowsTravelFirst(function (val) {\n        // '-' is regarded as null/undefined.\n        if (val != null && val !== '-') {\n          if (isString(val)) {\n            startIndex == null && (startIndex = 1);\n          } else {\n            startIndex = 0;\n          }\n        } // 10 is an experience number, avoid long loop.\n\n      }, seriesLayoutBy, data, 10);\n    } else {\n      startIndex = sourceHeader ? 1 : 0;\n    }\n\n    if (!dimensionsDefine && startIndex === 1) {\n      dimensionsDefine = [];\n      arrayRowsTravelFirst(function (val, index) {\n        dimensionsDefine[index] = val != null ? val : '';\n      }, seriesLayoutBy, data);\n    }\n\n    dimensionsDetectCount = dimensionsDefine ? dimensionsDefine.length : seriesLayoutBy === SERIES_LAYOUT_BY_ROW ? data.length : data[0] ? data[0].length : null;\n  } else if (sourceFormat === SOURCE_FORMAT_OBJECT_ROWS) {\n    if (!dimensionsDefine) {\n      dimensionsDefine = objectRowsCollectDimensions(data);\n      findPotentialName = true;\n    }\n  } else if (sourceFormat === SOURCE_FORMAT_KEYED_COLUMNS) {\n    if (!dimensionsDefine) {\n      dimensionsDefine = [];\n      findPotentialName = true;\n      each(data, function (colArr, key) {\n        dimensionsDefine.push(key);\n      });\n    }\n  } else if (sourceFormat === SOURCE_FORMAT_ORIGINAL) {\n    var value0 = getDataItemValue(data[0]);\n    dimensionsDetectCount = isArray(value0) && value0.length || 1;\n  } else if (sourceFormat === SOURCE_FORMAT_TYPED_ARRAY) {}\n\n  var potentialNameDimIndex;\n\n  if (findPotentialName) {\n    each(dimensionsDefine, function (dim, idx) {\n      if ((isObject(dim) ? dim.name : dim) === 'name') {\n        potentialNameDimIndex = idx;\n      }\n    });\n  }\n\n  return {\n    startIndex: startIndex,\n    dimensionsDefine: normalizeDimensionsDefine(dimensionsDefine),\n    dimensionsDetectCount: dimensionsDetectCount,\n    potentialNameDimIndex: potentialNameDimIndex // TODO: potentialIdDimIdx\n\n  };\n} // Consider dimensions defined like ['A', 'price', 'B', 'price', 'C', 'price'],\n// which is reasonable. But dimension name is duplicated.\n// Returns undefined or an array contains only object without null/undefiend or string.\n\n\nfunction normalizeDimensionsDefine(dimensionsDefine) {\n  if (!dimensionsDefine) {\n    // The meaning of null/undefined is different from empty array.\n    return;\n  }\n\n  var nameMap = createHashMap();\n  return map(dimensionsDefine, function (item, index) {\n    item = extend({}, isObject(item) ? item : {\n      name: item\n    }); // User can set null in dimensions.\n    // We dont auto specify name, othewise a given name may\n    // cause it be refered unexpectedly.\n\n    if (item.name == null) {\n      return item;\n    } // Also consider number form like 2012.\n\n\n    item.name += ''; // User may also specify displayName.\n    // displayName will always exists except user not\n    // specified or dim name is not specified or detected.\n    // (A auto generated dim name will not be used as\n    // displayName).\n\n    if (item.displayName == null) {\n      item.displayName = item.name;\n    }\n\n    var exist = nameMap.get(item.name);\n\n    if (!exist) {\n      nameMap.set(item.name, {\n        count: 1\n      });\n    } else {\n      item.name += '-' + exist.count++;\n    }\n\n    return item;\n  });\n}\n\nfunction arrayRowsTravelFirst(cb, seriesLayoutBy, data, maxLoop) {\n  maxLoop == null && (maxLoop = Infinity);\n\n  if (seriesLayoutBy === SERIES_LAYOUT_BY_ROW) {\n    for (var i = 0; i < data.length && i < maxLoop; i++) {\n      cb(data[i] ? data[i][0] : null, i);\n    }\n  } else {\n    var value0 = data[0] || [];\n\n    for (var i = 0; i < value0.length && i < maxLoop; i++) {\n      cb(value0[i], i);\n    }\n  }\n}\n\nfunction objectRowsCollectDimensions(data) {\n  var firstIndex = 0;\n  var obj;\n\n  while (firstIndex < data.length && !(obj = data[firstIndex++])) {} // jshint ignore: line\n\n\n  if (obj) {\n    var dimensions = [];\n    each(obj, function (value, key) {\n      dimensions.push(key);\n    });\n    return dimensions;\n  }\n} // ??? TODO merge to completedimensions, where also has\n// default encode making logic. And the default rule\n// should depends on series? consider 'map'.\n\n\nfunction makeDefaultEncode(seriesModel, datasetModel, data, sourceFormat, seriesLayoutBy, completeResult) {\n  var coordSysDefine = getCoordSysDefineBySeries(seriesModel);\n  var encode = {}; // var encodeTooltip = [];\n  // var encodeLabel = [];\n\n  var encodeItemName = [];\n  var encodeSeriesName = [];\n  var seriesType = seriesModel.subType; // ??? TODO refactor: provide by series itself.\n  // Consider the case: 'map' series is based on geo coordSys,\n  // 'graph', 'heatmap' can be based on cartesian. But can not\n  // give default rule simply here.\n\n  var nSeriesMap = createHashMap(['pie', 'map', 'funnel']);\n  var cSeriesMap = createHashMap(['line', 'bar', 'pictorialBar', 'scatter', 'effectScatter', 'candlestick', 'boxplot']); // Usually in this case series will use the first data\n  // dimension as the \"value\" dimension, or other default\n  // processes respectively.\n\n  if (coordSysDefine && cSeriesMap.get(seriesType) != null) {\n    var ecModel = seriesModel.ecModel;\n    var datasetMap = inner(ecModel).datasetMap;\n    var key = datasetModel.uid + '_' + seriesLayoutBy;\n    var datasetRecord = datasetMap.get(key) || datasetMap.set(key, {\n      categoryWayDim: 1,\n      valueWayDim: 0\n    }); // TODO\n    // Auto detect first time axis and do arrangement.\n\n    each(coordSysDefine.coordSysDims, function (coordDim) {\n      // In value way.\n      if (coordSysDefine.firstCategoryDimIndex == null) {\n        var dataDim = datasetRecord.valueWayDim++;\n        encode[coordDim] = dataDim; // ??? TODO give a better default series name rule?\n        // especially when encode x y specified.\n        // consider: when mutiple series share one dimension\n        // category axis, series name should better use\n        // the other dimsion name. On the other hand, use\n        // both dimensions name.\n\n        encodeSeriesName.push(dataDim); // encodeTooltip.push(dataDim);\n        // encodeLabel.push(dataDim);\n      } // In category way, category axis.\n      else if (coordSysDefine.categoryAxisMap.get(coordDim)) {\n          encode[coordDim] = 0;\n          encodeItemName.push(0);\n        } // In category way, non-category axis.\n        else {\n            var dataDim = datasetRecord.categoryWayDim++;\n            encode[coordDim] = dataDim; // encodeTooltip.push(dataDim);\n            // encodeLabel.push(dataDim);\n\n            encodeSeriesName.push(dataDim);\n          }\n    });\n  } // Do not make a complex rule! Hard to code maintain and not necessary.\n  // ??? TODO refactor: provide by series itself.\n  // [{name: ..., value: ...}, ...] like:\n  else if (nSeriesMap.get(seriesType) != null) {\n      // Find the first not ordinal. (5 is an experience value)\n      var firstNotOrdinal;\n\n      for (var i = 0; i < 5 && firstNotOrdinal == null; i++) {\n        if (!doGuessOrdinal(data, sourceFormat, seriesLayoutBy, completeResult.dimensionsDefine, completeResult.startIndex, i)) {\n          firstNotOrdinal = i;\n        }\n      }\n\n      if (firstNotOrdinal != null) {\n        encode.value = firstNotOrdinal;\n        var nameDimIndex = completeResult.potentialNameDimIndex || Math.max(firstNotOrdinal - 1, 0); // By default, label use itemName in charts.\n        // So we dont set encodeLabel here.\n\n        encodeSeriesName.push(nameDimIndex);\n        encodeItemName.push(nameDimIndex); // encodeTooltip.push(firstNotOrdinal);\n      }\n    } // encodeTooltip.length && (encode.tooltip = encodeTooltip);\n  // encodeLabel.length && (encode.label = encodeLabel);\n\n\n  encodeItemName.length && (encode.itemName = encodeItemName);\n  encodeSeriesName.length && (encode.seriesName = encodeSeriesName);\n  return encode;\n}\n/**\n * If return null/undefined, indicate that should not use datasetModel.\n */\n\n\nfunction getDatasetModel(seriesModel) {\n  var option = seriesModel.option; // Caution: consider the scenario:\n  // A dataset is declared and a series is not expected to use the dataset,\n  // and at the beginning `setOption({series: { noData })` (just prepare other\n  // option but no data), then `setOption({series: {data: [...]}); In this case,\n  // the user should set an empty array to avoid that dataset is used by default.\n\n  var thisData = option.data;\n\n  if (!thisData) {\n    return seriesModel.ecModel.getComponent('dataset', option.datasetIndex || 0);\n  }\n}\n/**\n * The rule should not be complex, otherwise user might not\n * be able to known where the data is wrong.\n * The code is ugly, but how to make it neat?\n *\n * @param {module:echars/data/Source} source\n * @param {number} dimIndex\n * @return {boolean} Whether ordinal.\n */\n\n\nfunction guessOrdinal(source, dimIndex) {\n  return doGuessOrdinal(source.data, source.sourceFormat, source.seriesLayoutBy, source.dimensionsDefine, source.startIndex, dimIndex);\n} // dimIndex may be overflow source data.\n\n\nfunction doGuessOrdinal(data, sourceFormat, seriesLayoutBy, dimensionsDefine, startIndex, dimIndex) {\n  var result; // Experience value.\n\n  var maxLoop = 5;\n\n  if (isTypedArray(data)) {\n    return false;\n  } // When sourceType is 'objectRows' or 'keyedColumns', dimensionsDefine\n  // always exists in source.\n\n\n  var dimName;\n\n  if (dimensionsDefine) {\n    dimName = dimensionsDefine[dimIndex];\n    dimName = isObject(dimName) ? dimName.name : dimName;\n  }\n\n  if (sourceFormat === SOURCE_FORMAT_ARRAY_ROWS) {\n    if (seriesLayoutBy === SERIES_LAYOUT_BY_ROW) {\n      var sample = data[dimIndex];\n\n      for (var i = 0; i < (sample || []).length && i < maxLoop; i++) {\n        if ((result = detectValue(sample[startIndex + i])) != null) {\n          return result;\n        }\n      }\n    } else {\n      for (var i = 0; i < data.length && i < maxLoop; i++) {\n        var row = data[startIndex + i];\n\n        if (row && (result = detectValue(row[dimIndex])) != null) {\n          return result;\n        }\n      }\n    }\n  } else if (sourceFormat === SOURCE_FORMAT_OBJECT_ROWS) {\n    if (!dimName) {\n      return;\n    }\n\n    for (var i = 0; i < data.length && i < maxLoop; i++) {\n      var item = data[i];\n\n      if (item && (result = detectValue(item[dimName])) != null) {\n        return result;\n      }\n    }\n  } else if (sourceFormat === SOURCE_FORMAT_KEYED_COLUMNS) {\n    if (!dimName) {\n      return;\n    }\n\n    var sample = data[dimName];\n\n    if (!sample || isTypedArray(sample)) {\n      return false;\n    }\n\n    for (var i = 0; i < sample.length && i < maxLoop; i++) {\n      if ((result = detectValue(sample[i])) != null) {\n        return result;\n      }\n    }\n  } else if (sourceFormat === SOURCE_FORMAT_ORIGINAL) {\n    for (var i = 0; i < data.length && i < maxLoop; i++) {\n      var item = data[i];\n      var val = getDataItemValue(item);\n\n      if (!isArray(val)) {\n        return false;\n      }\n\n      if ((result = detectValue(val[dimIndex])) != null) {\n        return result;\n      }\n    }\n  }\n\n  function detectValue(val) {\n    // Consider usage convenience, '1', '2' will be treated as \"number\".\n    // `isFinit('')` get `true`.\n    if (val != null && isFinite(val) && val !== '') {\n      return false;\n    } else if (isString(val) && val !== '-') {\n      return true;\n    }\n  }\n\n  return false;\n}\n\nexports.detectSourceFormat = detectSourceFormat;\nexports.getSource = getSource;\nexports.resetSourceDefaulter = resetSourceDefaulter;\nexports.prepareSource = prepareSource;\nexports.guessOrdinal = guessOrdinal;\n\n/***/ }),\n/* 34 */\n/***/ (function(module, exports) {\n\nvar g;\r\n\r\n// This works in non-strict mode\r\ng = (function() {\r\n\treturn this;\r\n})();\r\n\r\ntry {\r\n\t// This works if eval is allowed (see CSP)\r\n\tg = g || Function(\"return this\")() || (1, eval)(\"this\");\r\n} catch (e) {\r\n\t// This works if the window reference is available\r\n\tif (typeof window === \"object\") g = window;\r\n}\r\n\r\n// g can still be undefined, but nothing to do about it...\r\n// We return undefined, instead of nothing here, so it's\r\n// easier to handle this case. if(!global) { ...}\r\n\r\nmodule.exports = g;\r\n\n\n/***/ }),\n/* 35 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar _config = __webpack_require__(6);\n\nvar __DEV__ = _config.__DEV__;\n\nvar _util = __webpack_require__(0);\n\nvar createHashMap = _util.createHashMap;\nvar retrieve = _util.retrieve;\nvar each = _util.each;\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n/**\n * Helper for model references.\n * There are many manners to refer axis/coordSys.\n */\n// TODO\n// merge relevant logic to this file?\n// check: \"modelHelper\" of tooltip and \"BrushTargetManager\".\n\n/**\n * @return {Object} For example:\n * {\n *     coordSysName: 'cartesian2d',\n *     coordSysDims: ['x', 'y', ...],\n *     axisMap: HashMap({\n *         x: xAxisModel,\n *         y: yAxisModel\n *     }),\n *     categoryAxisMap: HashMap({\n *         x: xAxisModel,\n *         y: undefined\n *     }),\n *     // It also indicate that whether there is category axis.\n *     firstCategoryDimIndex: 1,\n *     // To replace user specified encode.\n * }\n */\nfunction getCoordSysDefineBySeries(seriesModel) {\n  var coordSysName = seriesModel.get('coordinateSystem');\n  var result = {\n    coordSysName: coordSysName,\n    coordSysDims: [],\n    axisMap: createHashMap(),\n    categoryAxisMap: createHashMap()\n  };\n  var fetch = fetchers[coordSysName];\n\n  if (fetch) {\n    fetch(seriesModel, result, result.axisMap, result.categoryAxisMap);\n    return result;\n  }\n}\n\nvar fetchers = {\n  cartesian2d: function (seriesModel, result, axisMap, categoryAxisMap) {\n    var xAxisModel = seriesModel.getReferringComponents('xAxis')[0];\n    var yAxisModel = seriesModel.getReferringComponents('yAxis')[0];\n    result.coordSysDims = ['x', 'y'];\n    axisMap.set('x', xAxisModel);\n    axisMap.set('y', yAxisModel);\n\n    if (isCategory(xAxisModel)) {\n      categoryAxisMap.set('x', xAxisModel);\n      result.firstCategoryDimIndex = 0;\n    }\n\n    if (isCategory(yAxisModel)) {\n      categoryAxisMap.set('y', yAxisModel);\n      result.firstCategoryDimIndex = 1;\n    }\n  },\n  singleAxis: function (seriesModel, result, axisMap, categoryAxisMap) {\n    var singleAxisModel = seriesModel.getReferringComponents('singleAxis')[0];\n    result.coordSysDims = ['single'];\n    axisMap.set('single', singleAxisModel);\n\n    if (isCategory(singleAxisModel)) {\n      categoryAxisMap.set('single', singleAxisModel);\n      result.firstCategoryDimIndex = 0;\n    }\n  },\n  polar: function (seriesModel, result, axisMap, categoryAxisMap) {\n    var polarModel = seriesModel.getReferringComponents('polar')[0];\n    var radiusAxisModel = polarModel.findAxisModel('radiusAxis');\n    var angleAxisModel = polarModel.findAxisModel('angleAxis');\n    result.coordSysDims = ['radius', 'angle'];\n    axisMap.set('radius', radiusAxisModel);\n    axisMap.set('angle', angleAxisModel);\n\n    if (isCategory(radiusAxisModel)) {\n      categoryAxisMap.set('radius', radiusAxisModel);\n      result.firstCategoryDimIndex = 0;\n    }\n\n    if (isCategory(angleAxisModel)) {\n      categoryAxisMap.set('angle', angleAxisModel);\n      result.firstCategoryDimIndex = 1;\n    }\n  },\n  geo: function (seriesModel, result, axisMap, categoryAxisMap) {\n    result.coordSysDims = ['lng', 'lat'];\n  },\n  parallel: function (seriesModel, result, axisMap, categoryAxisMap) {\n    var ecModel = seriesModel.ecModel;\n    var parallelModel = ecModel.getComponent('parallel', seriesModel.get('parallelIndex'));\n    var coordSysDims = result.coordSysDims = parallelModel.dimensions.slice();\n    each(parallelModel.parallelAxisIndex, function (axisIndex, index) {\n      var axisModel = ecModel.getComponent('parallelAxis', axisIndex);\n      var axisDim = coordSysDims[index];\n      axisMap.set(axisDim, axisModel);\n\n      if (isCategory(axisModel) && result.firstCategoryDimIndex == null) {\n        categoryAxisMap.set(axisDim, axisModel);\n        result.firstCategoryDimIndex = index;\n      }\n    });\n  }\n};\n\nfunction isCategory(axisModel) {\n  return axisModel.get('type') === 'category';\n}\n\nexports.getCoordSysDefineBySeries = getCoordSysDefineBySeries;\n\n/***/ }),\n/* 36 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar _config = __webpack_require__(6);\n\nvar __DEV__ = _config.__DEV__;\n\nvar zrUtil = __webpack_require__(0);\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\nvar TYPE_DELIMITER = '.';\nvar IS_CONTAINER = '___EC__COMPONENT__CONTAINER___';\n/**\n * Notice, parseClassType('') should returns {main: '', sub: ''}\n * @public\n */\n\nfunction parseClassType(componentType) {\n  var ret = {\n    main: '',\n    sub: ''\n  };\n\n  if (componentType) {\n    componentType = componentType.split(TYPE_DELIMITER);\n    ret.main = componentType[0] || '';\n    ret.sub = componentType[1] || '';\n  }\n\n  return ret;\n}\n/**\n * @public\n */\n\n\nfunction checkClassType(componentType) {\n  zrUtil.assert(/^[a-zA-Z0-9_]+([.][a-zA-Z0-9_]+)?$/.test(componentType), 'componentType \"' + componentType + '\" illegal');\n}\n/**\n * @public\n */\n\n\nfunction enableClassExtend(RootClass, mandatoryMethods) {\n  RootClass.$constructor = RootClass;\n\n  RootClass.extend = function (proto) {\n    var superClass = this;\n\n    var ExtendedClass = function () {\n      if (!proto.$constructor) {\n        superClass.apply(this, arguments);\n      } else {\n        proto.$constructor.apply(this, arguments);\n      }\n    };\n\n    zrUtil.extend(ExtendedClass.prototype, proto);\n    ExtendedClass.extend = this.extend;\n    ExtendedClass.superCall = superCall;\n    ExtendedClass.superApply = superApply;\n    zrUtil.inherits(ExtendedClass, this);\n    ExtendedClass.superClass = superClass;\n    return ExtendedClass;\n  };\n}\n\nvar classBase = 0;\n/**\n * Can not use instanceof, consider different scope by\n * cross domain or es module import in ec extensions.\n * Mount a method \"isInstance()\" to Clz.\n */\n\nfunction enableClassCheck(Clz) {\n  var classAttr = ['__\\0is_clz', classBase++, Math.random().toFixed(3)].join('_');\n  Clz.prototype[classAttr] = true;\n\n  Clz.isInstance = function (obj) {\n    return !!(obj && obj[classAttr]);\n  };\n} // superCall should have class info, which can not be fetch from 'this'.\n// Consider this case:\n// class A has method f,\n// class B inherits class A, overrides method f, f call superApply('f'),\n// class C inherits class B, do not overrides method f,\n// then when method of class C is called, dead loop occured.\n\n\nfunction superCall(context, methodName) {\n  var args = zrUtil.slice(arguments, 2);\n  return this.superClass.prototype[methodName].apply(context, args);\n}\n\nfunction superApply(context, methodName, args) {\n  return this.superClass.prototype[methodName].apply(context, args);\n}\n/**\n * @param {Object} entity\n * @param {Object} options\n * @param {boolean} [options.registerWhenExtend]\n * @public\n */\n\n\nfunction enableClassManagement(entity, options) {\n  options = options || {};\n  /**\n   * Component model classes\n   * key: componentType,\n   * value:\n   *     componentClass, when componentType is 'xxx'\n   *     or Object.<subKey, componentClass>, when componentType is 'xxx.yy'\n   * @type {Object}\n   */\n\n  var storage = {};\n\n  entity.registerClass = function (Clazz, componentType) {\n    if (componentType) {\n      checkClassType(componentType);\n      componentType = parseClassType(componentType);\n\n      if (!componentType.sub) {\n        storage[componentType.main] = Clazz;\n      } else if (componentType.sub !== IS_CONTAINER) {\n        var container = makeContainer(componentType);\n        container[componentType.sub] = Clazz;\n      }\n    }\n\n    return Clazz;\n  };\n\n  entity.getClass = function (componentMainType, subType, throwWhenNotFound) {\n    var Clazz = storage[componentMainType];\n\n    if (Clazz && Clazz[IS_CONTAINER]) {\n      Clazz = subType ? Clazz[subType] : null;\n    }\n\n    if (throwWhenNotFound && !Clazz) {\n      throw new Error(!subType ? componentMainType + '.' + 'type should be specified.' : 'Component ' + componentMainType + '.' + (subType || '') + ' not exists. Load it first.');\n    }\n\n    return Clazz;\n  };\n\n  entity.getClassesByMainType = function (componentType) {\n    componentType = parseClassType(componentType);\n    var result = [];\n    var obj = storage[componentType.main];\n\n    if (obj && obj[IS_CONTAINER]) {\n      zrUtil.each(obj, function (o, type) {\n        type !== IS_CONTAINER && result.push(o);\n      });\n    } else {\n      result.push(obj);\n    }\n\n    return result;\n  };\n\n  entity.hasClass = function (componentType) {\n    // Just consider componentType.main.\n    componentType = parseClassType(componentType);\n    return !!storage[componentType.main];\n  };\n  /**\n   * @return {Array.<string>} Like ['aa', 'bb'], but can not be ['aa.xx']\n   */\n\n\n  entity.getAllClassMainTypes = function () {\n    var types = [];\n    zrUtil.each(storage, function (obj, type) {\n      types.push(type);\n    });\n    return types;\n  };\n  /**\n   * If a main type is container and has sub types\n   * @param  {string}  mainType\n   * @return {boolean}\n   */\n\n\n  entity.hasSubTypes = function (componentType) {\n    componentType = parseClassType(componentType);\n    var obj = storage[componentType.main];\n    return obj && obj[IS_CONTAINER];\n  };\n\n  entity.parseClassType = parseClassType;\n\n  function makeContainer(componentType) {\n    var container = storage[componentType.main];\n\n    if (!container || !container[IS_CONTAINER]) {\n      container = storage[componentType.main] = {};\n      container[IS_CONTAINER] = true;\n    }\n\n    return container;\n  }\n\n  if (options.registerWhenExtend) {\n    var originalExtend = entity.extend;\n\n    if (originalExtend) {\n      entity.extend = function (proto) {\n        var ExtendedClass = originalExtend.call(this, proto);\n        return entity.registerClass(ExtendedClass, proto.type);\n      };\n    }\n  }\n\n  return entity;\n}\n/**\n * @param {string|Array.<string>} properties\n */\n\n\nfunction setReadOnly(obj, properties) {// FIXME It seems broken in IE8 simulation of IE11\n  // if (!zrUtil.isArray(properties)) {\n  //     properties = properties != null ? [properties] : [];\n  // }\n  // zrUtil.each(properties, function (prop) {\n  //     var value = obj[prop];\n  //     Object.defineProperty\n  //         && Object.defineProperty(obj, prop, {\n  //             value: value, writable: false\n  //         });\n  //     zrUtil.isArray(obj[prop])\n  //         && Object.freeze\n  //         && Object.freeze(obj[prop]);\n  // });\n}\n\nexports.parseClassType = parseClassType;\nexports.enableClassExtend = enableClassExtend;\nexports.enableClassCheck = enableClassCheck;\nexports.enableClassManagement = enableClassManagement;\nexports.setReadOnly = setReadOnly;\n\n/***/ }),\n/* 37 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar _util = __webpack_require__(0);\n\nvar each = _util.each;\nvar createHashMap = _util.createHashMap;\nvar assert = _util.assert;\n\nvar _config = __webpack_require__(6);\n\nvar __DEV__ = _config.__DEV__;\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\nvar OTHER_DIMENSIONS = createHashMap(['tooltip', 'label', 'itemName', 'itemId', 'seriesName']);\n\nfunction summarizeDimensions(data) {\n  var summary = {};\n  var encode = summary.encode = {};\n  var notExtraCoordDimMap = createHashMap();\n  var defaultedLabel = [];\n  var defaultedTooltip = [];\n  each(data.dimensions, function (dimName) {\n    var dimItem = data.getDimensionInfo(dimName);\n    var coordDim = dimItem.coordDim;\n\n    if (coordDim) {\n      var coordDimArr = encode[coordDim];\n\n      if (!encode.hasOwnProperty(coordDim)) {\n        coordDimArr = encode[coordDim] = [];\n      }\n\n      coordDimArr[dimItem.coordDimIndex] = dimName;\n\n      if (!dimItem.isExtraCoord) {\n        notExtraCoordDimMap.set(coordDim, 1); // Use the last coord dim (and label friendly) as default label,\n        // because when dataset is used, it is hard to guess which dimension\n        // can be value dimension. If both show x, y on label is not look good,\n        // and conventionally y axis is focused more.\n\n        if (mayLabelDimType(dimItem.type)) {\n          defaultedLabel[0] = dimName;\n        }\n      }\n\n      if (dimItem.defaultTooltip) {\n        defaultedTooltip.push(dimName);\n      }\n    }\n\n    OTHER_DIMENSIONS.each(function (v, otherDim) {\n      var otherDimArr = encode[otherDim];\n\n      if (!encode.hasOwnProperty(otherDim)) {\n        otherDimArr = encode[otherDim] = [];\n      }\n\n      var dimIndex = dimItem.otherDims[otherDim];\n\n      if (dimIndex != null && dimIndex !== false) {\n        otherDimArr[dimIndex] = dimItem.name;\n      }\n    });\n  });\n  var dataDimsOnCoord = [];\n  var encodeFirstDimNotExtra = {};\n  notExtraCoordDimMap.each(function (v, coordDim) {\n    var dimArr = encode[coordDim]; // ??? FIXME extra coord should not be set in dataDimsOnCoord.\n    // But should fix the case that radar axes: simplify the logic\n    // of `completeDimension`, remove `extraPrefix`.\n\n    encodeFirstDimNotExtra[coordDim] = dimArr[0]; // Not necessary to remove duplicate, because a data\n    // dim canot on more than one coordDim.\n\n    dataDimsOnCoord = dataDimsOnCoord.concat(dimArr);\n  });\n  summary.dataDimsOnCoord = dataDimsOnCoord;\n  summary.encodeFirstDimNotExtra = encodeFirstDimNotExtra;\n  var encodeLabel = encode.label; // FIXME `encode.label` is not recommanded, because formatter can not be set\n  // in this way. Use label.formatter instead. May be remove this approach someday.\n\n  if (encodeLabel && encodeLabel.length) {\n    defaultedLabel = encodeLabel.slice();\n  }\n\n  var encodeTooltip = encode.tooltip;\n\n  if (encodeTooltip && encodeTooltip.length) {\n    defaultedTooltip = encodeTooltip.slice();\n  } else if (!defaultedTooltip.length) {\n    defaultedTooltip = defaultedLabel.slice();\n  }\n\n  encode.defaultedLabel = defaultedLabel;\n  encode.defaultedTooltip = defaultedTooltip;\n  return summary;\n}\n\nfunction getDimensionTypeByAxis(axisType) {\n  return axisType === 'category' ? 'ordinal' : axisType === 'time' ? 'time' : 'float';\n}\n\nfunction mayLabelDimType(dimType) {\n  // In most cases, ordinal and time do not suitable for label.\n  // Ordinal info can be displayed on axis. Time is too long.\n  return !(dimType === 'ordinal' || dimType === 'time');\n} // function findTheLastDimMayLabel(data) {\n//     // Get last value dim\n//     var dimensions = data.dimensions.slice();\n//     var valueType;\n//     var valueDim;\n//     while (dimensions.length && (\n//         valueDim = dimensions.pop(),\n//         valueType = data.getDimensionInfo(valueDim).type,\n//         valueType === 'ordinal' || valueType === 'time'\n//     )) {} // jshint ignore:line\n//     return valueDim;\n// }\n\n\nexports.OTHER_DIMENSIONS = OTHER_DIMENSIONS;\nexports.summarizeDimensions = summarizeDimensions;\nexports.getDimensionTypeByAxis = getDimensionTypeByAxis;\n\n/***/ }),\n/* 38 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar echarts = __webpack_require__(5);\nvar numberUtil = echarts.number;\nvar symbolUtil = __webpack_require__(39);\nvar parsePercent = numberUtil.parsePercent;\n\nvar LiquidLayout = __webpack_require__(79);\n\nfunction getShallow(model, path) {\n    return model && model.getShallow(path);\n}\n\necharts.extendChartView({\n\n    type: 'liquidFill',\n\n    render: function (seriesModel, ecModel, api) {\n        var group = this.group;\n        group.removeAll();\n\n        var data = seriesModel.getData();\n\n        var itemModel = data.getItemModel(0);\n\n        var center = itemModel.get('center');\n        var radius = itemModel.get('radius');\n\n        var width = api.getWidth();\n        var height = api.getHeight();\n        var size = Math.min(width, height);\n        // itemStyle\n        var outlineDistance = 0;\n        var outlineBorderWidth = 0;\n        var showOutline = seriesModel.get('outline.show');\n\n        if (showOutline) {\n            outlineDistance = seriesModel.get('outline.borderDistance');\n            outlineBorderWidth = parsePercent(\n                seriesModel.get('outline.itemStyle.borderWidth'), size\n            );\n        }\n\n        var cx = parsePercent(center[0], width);\n        var cy = parsePercent(center[1], height);\n\n        var outterRadius;\n        var innerRadius;\n        var paddingRadius;\n\n        var isFillContainer = false;\n\n        var symbol = seriesModel.get('shape');\n        if (symbol === 'container') {\n            // a shape that fully fills the container\n            isFillContainer = true;\n\n            outterRadius = [\n                width / 2,\n                height / 2\n            ];\n            innerRadius = [\n                outterRadius[0] - outlineBorderWidth / 2,\n                outterRadius[1] - outlineBorderWidth / 2\n            ];\n            paddingRadius = [\n                parsePercent(outlineDistance, width),\n                parsePercent(outlineDistance, height)\n            ];\n\n            radius = [\n                Math.max(innerRadius[0] - paddingRadius[0], 0),\n                Math.max(innerRadius[1] - paddingRadius[1], 0)\n            ];\n        }\n        else {\n            outterRadius = parsePercent(radius, size) / 2;\n            innerRadius = outterRadius - outlineBorderWidth / 2;\n            paddingRadius = parsePercent(outlineDistance, size);\n\n            radius = Math.max(innerRadius - paddingRadius, 0);\n        }\n\n        if (showOutline) {\n            var outline = getOutline();\n            outline.style.lineWidth = outlineBorderWidth;\n            group.add(getOutline());\n        }\n\n        var left = isFillContainer ? 0 : cx - radius;\n        var top = isFillContainer ? 0 : cy - radius;\n\n        var wavePath = null;\n\n        group.add(getBackground());\n\n        // each data item for a wave\n        var oldData = this._data;\n        var waves = [];\n        data.diff(oldData)\n            .add(function (idx) {\n                var wave = getWave(idx, false);\n\n                var waterLevel = wave.shape.waterLevel;\n                wave.shape.waterLevel = isFillContainer ? height / 2 : radius;\n                echarts.graphic.initProps(wave, {\n                    shape: {\n                        waterLevel: waterLevel\n                    }\n                }, seriesModel);\n\n                wave.z2 = 2;\n                setWaveAnimation(idx, wave, null);\n\n                group.add(wave);\n                data.setItemGraphicEl(idx, wave);\n                waves.push(wave);\n            })\n            .update(function (newIdx, oldIdx) {\n                var waveElement = oldData.getItemGraphicEl(oldIdx);\n\n                // new wave is used to calculate position, but not added\n                var newWave = getWave(newIdx, false, waveElement);\n\n                // changes with animation\n                var shape = {};\n                var shapeAttrs = ['amplitude', 'cx', 'cy', 'phase', 'radius', 'radiusY', 'waterLevel', 'waveLength'];\n                for (var i = 0; i < shapeAttrs.length; ++i) {\n                    var attr = shapeAttrs[i];\n                    if (newWave.shape.hasOwnProperty(attr)) {\n                        shape[attr] = newWave.shape[attr];\n                    }\n                }\n\n                var style = {};\n                var styleAttrs = ['fill', 'opacity', 'shadowBlur', 'shadowColor'];\n                for (var i = 0; i < styleAttrs.length; ++i) {\n                    var attr = styleAttrs[i];\n                    if (newWave.style.hasOwnProperty(attr)) {\n                        style[attr] = newWave.style[attr];\n                    }\n                }\n\n                if (isFillContainer) {\n                    shape.radiusY = height / 2;\n                }\n\n                // changes with animation\n                echarts.graphic.updateProps(waveElement, {\n                    shape: shape,\n                    style: style\n                }, seriesModel);\n\n                // instant changes\n                waveElement.position = newWave.position;\n                waveElement.setClipPath(newWave.clipPath);\n                waveElement.shape.inverse = newWave.inverse;\n\n                setWaveAnimation(newIdx, waveElement, waveElement);\n                group.add(waveElement);\n                data.setItemGraphicEl(newIdx, waveElement);\n                waves.push(waveElement);\n            })\n            .remove(function (idx) {\n                var wave = oldData.getItemGraphicEl(idx);\n                group.remove(wave);\n            })\n            .execute();\n\n        if (itemModel.get('label.show')) {\n            group.add(getText(waves));\n        }\n\n        this._data = data;\n\n        /**\n         * Get path for outline, background and clipping\n         *\n         * @param {number} r outter radius of shape\n         * @param {boolean|undefined} isForClipping if the shape is used\n         *                                          for clipping\n         */\n        function getPath(r, isForClipping) {\n            if (symbol) {\n                // customed symbol path\n                if (symbol.indexOf('path://') === 0) {\n                    var path = echarts.graphic.makePath(symbol.slice(7), {});\n                    var bouding = path.getBoundingRect();\n                    var w = bouding.width;\n                    var h = bouding.height;\n                    if (w > h) {\n                        h = r * 2 / w * h;\n                        w = r * 2;\n                    }\n                    else {\n                        w = r * 2 / h * w;\n                        h = r * 2;\n                    }\n\n                    var left = isForClipping ? 0 : cx - w / 2;\n                    var top = isForClipping ? 0 : cy - h / 2;\n                    path = echarts.graphic.makePath(\n                        symbol.slice(7),\n                        {},\n                        new echarts.graphic.BoundingRect(left, top, w, h)\n                    );\n                    if (isForClipping) {\n                        path.position = [-w / 2, -h / 2];\n                    }\n                    return path;\n                }\n                else if (isFillContainer) {\n                    // fully fill the container\n                    var x = isForClipping ? -r[0] : cx - r[0];\n                    var y = isForClipping ? -r[1] : cy - r[1];\n                    return symbolUtil.createSymbol(\n                        'rect', x, y, r[0] * 2, r[1] * 2\n                    );\n                }\n                else {\n                    var x = isForClipping ? -r : cx - r;\n                    var y = isForClipping ? -r : cy - r;\n                    if (symbol === 'pin') {\n                        y += r;\n                    }\n                    else if (symbol === 'arrow') {\n                        y -= r;\n                    }\n                    return symbolUtil.createSymbol(symbol, x, y, r * 2, r * 2);\n                }\n            }\n\n            return new echarts.graphic.Circle({\n                shape: {\n                    cx: isForClipping ? 0 : cx,\n                    cy: isForClipping ? 0 : cy,\n                    r: r\n                }\n            });\n        }\n        /**\n         * Create outline\n         */\n        function getOutline() {\n            var outlinePath = getPath(outterRadius);\n            outlinePath.style.fill = null;\n\n            outlinePath.setStyle(seriesModel.getModel('outline.itemStyle')\n                .getItemStyle());\n\n            return outlinePath;\n        }\n\n        /**\n         * Create background\n         */\n        function getBackground() {\n            // Seperate stroke and fill, so we can use stroke to cover the alias of clipping.\n            var strokePath = getPath(radius);\n            strokePath.setStyle(seriesModel.getModel('backgroundStyle')\n                .getItemStyle());\n            strokePath.style.fill = null;\n\n            // Stroke is front of wave\n            strokePath.z2 = 5;\n\n            var fillPath = getPath(radius);\n            fillPath.setStyle(seriesModel.getModel('backgroundStyle')\n                .getItemStyle());\n            fillPath.style.stroke = null;\n\n            var group = new echarts.graphic.Group();\n            group.add(strokePath);\n            group.add(fillPath);\n\n            return group;\n        }\n\n        /**\n         * wave shape\n         */\n        function getWave(idx, isInverse, oldWave) {\n            var radiusX = isFillContainer ? radius[0] : radius;\n            var radiusY = isFillContainer ? height / 2 : radius;\n\n            var itemModel = data.getItemModel(idx);\n            var itemStyleModel = itemModel.getModel('itemStyle');\n            var phase = itemModel.get('phase');\n            var amplitude = parsePercent(itemModel.get('amplitude'),\n                radiusY * 2);\n            var waveLength = parsePercent(itemModel.get('waveLength'),\n                radiusX * 2);\n\n            var value = data.get('value', idx);\n            var waterLevel = radiusY - value * radiusY * 2;\n            phase = oldWave ? oldWave.shape.phase\n                : (phase === 'auto' ? idx * Math.PI / 4 : phase);\n            var normalStyle = itemStyleModel.getItemStyle();\n            if (!normalStyle.fill) {\n                var seriesColor = seriesModel.get('color');\n                var id = idx % seriesColor.length;\n                normalStyle.fill = seriesColor[id];\n            }\n\n            var x = radiusX * 2;\n            var wave = new LiquidLayout({\n                shape: {\n                    waveLength: waveLength,\n                    radius: radiusX,\n                    radiusY: radiusY,\n                    cx: x,\n                    cy: 0,\n                    waterLevel: waterLevel,\n                    amplitude: amplitude,\n                    phase: phase,\n                    inverse: isInverse\n                },\n                style: normalStyle,\n                position: [cx, cy]\n            });\n            wave.shape._waterLevel = waterLevel;\n\n            var hoverStyle = itemModel.getModel('emphasis.itemStyle')\n                .getItemStyle();\n            hoverStyle.lineWidth = 0;\n            echarts.graphic.setHoverStyle(wave, hoverStyle);\n\n            // clip out the part outside the circle\n            var clip = getPath(radius, true);\n            // set fill for clipPath, otherwise it will not trigger hover event\n            clip.setStyle({\n                fill: 'white'\n            });\n            wave.setClipPath(clip);\n\n            return wave;\n        }\n\n        function setWaveAnimation(idx, wave, oldWave) {\n            var itemModel = data.getItemModel(idx);\n\n            var maxSpeed = itemModel.get('period');\n            var direction = itemModel.get('direction');\n\n            var value = data.get('value', idx);\n\n            var phase = itemModel.get('phase');\n            phase = oldWave ? oldWave.shape.phase\n                : (phase === 'auto' ? idx * Math.PI / 4 : phase);\n\n            var defaultSpeed = function (maxSpeed) {\n                var cnt = data.count();\n                return cnt === 0 ? maxSpeed : maxSpeed *\n                    (0.2 + (cnt - idx) / cnt * 0.8);\n            };\n            var speed = 0;\n            if (maxSpeed === 'auto') {\n                speed = defaultSpeed(5000);\n            }\n            else {\n                speed = typeof maxSpeed === 'function'\n                    ? maxSpeed(value, idx) : maxSpeed;\n            }\n\n            // phase for moving left/right\n            var phaseOffset = 0;\n            if (direction === 'right' || direction == null) {\n                phaseOffset = Math.PI;\n            }\n            else if (direction === 'left') {\n                phaseOffset = -Math.PI;\n            }\n            else if (direction === 'none') {\n                phaseOffset = 0;\n            }\n            else {\n                console.error('Illegal direction value for liquid fill.');\n            }\n\n            // wave animation of moving left/right\n            if (direction !== 'none' && itemModel.get('waveAnimation')) {\n                wave\n                    .animate('shape', true)\n                    .when(0, {\n                        phase: phase\n                    })\n                    .when(speed / 2, {\n                        phase: phaseOffset + phase\n                    })\n                    .when(speed, {\n                        phase: phaseOffset * 2 + phase\n                    })\n                    .during(function () {\n                        if (wavePath) {\n                            wavePath.dirty(true);\n                        }\n                    })\n                    .start();\n            }\n        }\n\n        /**\n         * text on wave\n         */\n        function getText(waves) {\n            var labelModel = itemModel.getModel('label');\n\n            function formatLabel() {\n                var formatted = seriesModel.getFormattedLabel(0, 'normal');\n                var defaultVal = (data.get('value', 0) * 100);\n                var defaultLabel = data.getName(0) || seriesModel.name;\n                if (!isNaN(defaultVal)) {\n                    defaultLabel = defaultVal.toFixed(0) + '%';\n                }\n                return formatted == null ? defaultLabel : formatted;\n            }\n\n            var textOption = {\n                z2: 10,\n                shape: {\n                    x: left,\n                    y: top,\n                    width: (isFillContainer ? radius[0] : radius) * 2,\n                    height: (isFillContainer ? radius[1] : radius) * 2\n                },\n                style: {\n                    fill: 'transparent',\n                    text: formatLabel(),\n                    textAlign: labelModel.get('align'),\n                    textVerticalAlign: labelModel.get('baseline')\n                },\n                silent: true\n            };\n\n            var outsideTextRect = new echarts.graphic.Rect(textOption);\n            var color = labelModel.get('color');\n            echarts.graphic.setText(outsideTextRect.style, labelModel, color);\n\n            var insideTextRect = new echarts.graphic.Rect(textOption);\n            var insColor = labelModel.get('insideColor');\n            echarts.graphic.setText(insideTextRect.style, labelModel, insColor);\n            insideTextRect.style.textFill = insColor;\n\n            var group = new echarts.graphic.Group();\n            group.add(outsideTextRect);\n            group.add(insideTextRect);\n\n            // clip out waves for insideText\n            var boundingCircle = getPath(radius, true);\n\n            wavePath = new echarts.graphic.CompoundPath({\n                shape: {\n                    paths: waves\n                },\n                position: [cx, cy]\n            });\n\n            wavePath.setClipPath(boundingCircle);\n            insideTextRect.setClipPath(wavePath);\n\n            return group;\n        }\n    },\n\n    dispose: function () {\n        // dispose nothing here\n    }\n});\n\n\n/***/ }),\n/* 39 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar zrUtil = __webpack_require__(0);\n\nvar graphic = __webpack_require__(40);\n\nvar BoundingRect = __webpack_require__(3);\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n// Symbol factory\n\n/**\n * Triangle shape\n * @inner\n */\nvar Triangle = graphic.extendShape({\n  type: 'triangle',\n  shape: {\n    cx: 0,\n    cy: 0,\n    width: 0,\n    height: 0\n  },\n  buildPath: function (path, shape) {\n    var cx = shape.cx;\n    var cy = shape.cy;\n    var width = shape.width / 2;\n    var height = shape.height / 2;\n    path.moveTo(cx, cy - height);\n    path.lineTo(cx + width, cy + height);\n    path.lineTo(cx - width, cy + height);\n    path.closePath();\n  }\n});\n/**\n * Diamond shape\n * @inner\n */\n\nvar Diamond = graphic.extendShape({\n  type: 'diamond',\n  shape: {\n    cx: 0,\n    cy: 0,\n    width: 0,\n    height: 0\n  },\n  buildPath: function (path, shape) {\n    var cx = shape.cx;\n    var cy = shape.cy;\n    var width = shape.width / 2;\n    var height = shape.height / 2;\n    path.moveTo(cx, cy - height);\n    path.lineTo(cx + width, cy);\n    path.lineTo(cx, cy + height);\n    path.lineTo(cx - width, cy);\n    path.closePath();\n  }\n});\n/**\n * Pin shape\n * @inner\n */\n\nvar Pin = graphic.extendShape({\n  type: 'pin',\n  shape: {\n    // x, y on the cusp\n    x: 0,\n    y: 0,\n    width: 0,\n    height: 0\n  },\n  buildPath: function (path, shape) {\n    var x = shape.x;\n    var y = shape.y;\n    var w = shape.width / 5 * 3; // Height must be larger than width\n\n    var h = Math.max(w, shape.height);\n    var r = w / 2; // Dist on y with tangent point and circle center\n\n    var dy = r * r / (h - r);\n    var cy = y - h + r + dy;\n    var angle = Math.asin(dy / r); // Dist on x with tangent point and circle center\n\n    var dx = Math.cos(angle) * r;\n    var tanX = Math.sin(angle);\n    var tanY = Math.cos(angle);\n    var cpLen = r * 0.6;\n    var cpLen2 = r * 0.7;\n    path.moveTo(x - dx, cy + dy);\n    path.arc(x, cy, r, Math.PI - angle, Math.PI * 2 + angle);\n    path.bezierCurveTo(x + dx - tanX * cpLen, cy + dy + tanY * cpLen, x, y - cpLen2, x, y);\n    path.bezierCurveTo(x, y - cpLen2, x - dx + tanX * cpLen, cy + dy + tanY * cpLen, x - dx, cy + dy);\n    path.closePath();\n  }\n});\n/**\n * Arrow shape\n * @inner\n */\n\nvar Arrow = graphic.extendShape({\n  type: 'arrow',\n  shape: {\n    x: 0,\n    y: 0,\n    width: 0,\n    height: 0\n  },\n  buildPath: function (ctx, shape) {\n    var height = shape.height;\n    var width = shape.width;\n    var x = shape.x;\n    var y = shape.y;\n    var dx = width / 3 * 2;\n    ctx.moveTo(x, y);\n    ctx.lineTo(x + dx, y + height);\n    ctx.lineTo(x, y + height / 4 * 3);\n    ctx.lineTo(x - dx, y + height);\n    ctx.lineTo(x, y);\n    ctx.closePath();\n  }\n});\n/**\n * Map of path contructors\n * @type {Object.<string, module:zrender/graphic/Path>}\n */\n\nvar symbolCtors = {\n  line: graphic.Line,\n  rect: graphic.Rect,\n  roundRect: graphic.Rect,\n  square: graphic.Rect,\n  circle: graphic.Circle,\n  diamond: Diamond,\n  pin: Pin,\n  arrow: Arrow,\n  triangle: Triangle\n};\nvar symbolShapeMakers = {\n  line: function (x, y, w, h, shape) {\n    // FIXME\n    shape.x1 = x;\n    shape.y1 = y + h / 2;\n    shape.x2 = x + w;\n    shape.y2 = y + h / 2;\n  },\n  rect: function (x, y, w, h, shape) {\n    shape.x = x;\n    shape.y = y;\n    shape.width = w;\n    shape.height = h;\n  },\n  roundRect: function (x, y, w, h, shape) {\n    shape.x = x;\n    shape.y = y;\n    shape.width = w;\n    shape.height = h;\n    shape.r = Math.min(w, h) / 4;\n  },\n  square: function (x, y, w, h, shape) {\n    var size = Math.min(w, h);\n    shape.x = x;\n    shape.y = y;\n    shape.width = size;\n    shape.height = size;\n  },\n  circle: function (x, y, w, h, shape) {\n    // Put circle in the center of square\n    shape.cx = x + w / 2;\n    shape.cy = y + h / 2;\n    shape.r = Math.min(w, h) / 2;\n  },\n  diamond: function (x, y, w, h, shape) {\n    shape.cx = x + w / 2;\n    shape.cy = y + h / 2;\n    shape.width = w;\n    shape.height = h;\n  },\n  pin: function (x, y, w, h, shape) {\n    shape.x = x + w / 2;\n    shape.y = y + h / 2;\n    shape.width = w;\n    shape.height = h;\n  },\n  arrow: function (x, y, w, h, shape) {\n    shape.x = x + w / 2;\n    shape.y = y + h / 2;\n    shape.width = w;\n    shape.height = h;\n  },\n  triangle: function (x, y, w, h, shape) {\n    shape.cx = x + w / 2;\n    shape.cy = y + h / 2;\n    shape.width = w;\n    shape.height = h;\n  }\n};\nvar symbolBuildProxies = {};\nzrUtil.each(symbolCtors, function (Ctor, name) {\n  symbolBuildProxies[name] = new Ctor();\n});\nvar SymbolClz = graphic.extendShape({\n  type: 'symbol',\n  shape: {\n    symbolType: '',\n    x: 0,\n    y: 0,\n    width: 0,\n    height: 0\n  },\n  beforeBrush: function () {\n    var style = this.style;\n    var shape = this.shape; // FIXME\n\n    if (shape.symbolType === 'pin' && style.textPosition === 'inside') {\n      style.textPosition = ['50%', '40%'];\n      style.textAlign = 'center';\n      style.textVerticalAlign = 'middle';\n    }\n  },\n  buildPath: function (ctx, shape, inBundle) {\n    var symbolType = shape.symbolType;\n    var proxySymbol = symbolBuildProxies[symbolType];\n\n    if (shape.symbolType !== 'none') {\n      if (!proxySymbol) {\n        // Default rect\n        symbolType = 'rect';\n        proxySymbol = symbolBuildProxies[symbolType];\n      }\n\n      symbolShapeMakers[symbolType](shape.x, shape.y, shape.width, shape.height, proxySymbol.shape);\n      proxySymbol.buildPath(ctx, proxySymbol.shape, inBundle);\n    }\n  }\n}); // Provide setColor helper method to avoid determine if set the fill or stroke outside\n\nfunction symbolPathSetColor(color, innerColor) {\n  if (this.type !== 'image') {\n    var symbolStyle = this.style;\n    var symbolShape = this.shape;\n\n    if (symbolShape && symbolShape.symbolType === 'line') {\n      symbolStyle.stroke = color;\n    } else if (this.__isEmptyBrush) {\n      symbolStyle.stroke = color;\n      symbolStyle.fill = innerColor || '#fff';\n    } else {\n      // FIXME 判断图形默认是填充还是描边，使用 onlyStroke ?\n      symbolStyle.fill && (symbolStyle.fill = color);\n      symbolStyle.stroke && (symbolStyle.stroke = color);\n    }\n\n    this.dirty(false);\n  }\n}\n/**\n * Create a symbol element with given symbol configuration: shape, x, y, width, height, color\n * @param {string} symbolType\n * @param {number} x\n * @param {number} y\n * @param {number} w\n * @param {number} h\n * @param {string} color\n * @param {boolean} [keepAspect=false] whether to keep the ratio of w/h,\n *                            for path and image only.\n */\n\n\nfunction createSymbol(symbolType, x, y, w, h, color, keepAspect) {\n  // TODO Support image object, DynamicImage.\n  var isEmpty = symbolType.indexOf('empty') === 0;\n\n  if (isEmpty) {\n    symbolType = symbolType.substr(5, 1).toLowerCase() + symbolType.substr(6);\n  }\n\n  var symbolPath;\n\n  if (symbolType.indexOf('image://') === 0) {\n    symbolPath = graphic.makeImage(symbolType.slice(8), new BoundingRect(x, y, w, h), keepAspect ? 'center' : 'cover');\n  } else if (symbolType.indexOf('path://') === 0) {\n    symbolPath = graphic.makePath(symbolType.slice(7), {}, new BoundingRect(x, y, w, h), keepAspect ? 'center' : 'cover');\n  } else {\n    symbolPath = new SymbolClz({\n      shape: {\n        symbolType: symbolType,\n        x: x,\n        y: y,\n        width: w,\n        height: h\n      }\n    });\n  }\n\n  symbolPath.__isEmptyBrush = isEmpty;\n  symbolPath.setColor = symbolPathSetColor;\n  symbolPath.setColor(color);\n  return symbolPath;\n}\n\nexports.createSymbol = createSymbol;\n\n/***/ }),\n/* 40 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar zrUtil = __webpack_require__(0);\n\nvar pathTool = __webpack_require__(41);\n\nvar colorTool = __webpack_require__(19);\n\nvar matrix = __webpack_require__(10);\n\nvar vector = __webpack_require__(2);\n\nvar Path = __webpack_require__(1);\n\nvar Transformable = __webpack_require__(18);\n\nvar ZImage = __webpack_require__(60);\n\nexports.Image = ZImage;\n\nvar Group = __webpack_require__(61);\n\nexports.Group = Group;\n\nvar Text = __webpack_require__(62);\n\nexports.Text = Text;\n\nvar Circle = __webpack_require__(63);\n\nexports.Circle = Circle;\n\nvar Sector = __webpack_require__(64);\n\nexports.Sector = Sector;\n\nvar Ring = __webpack_require__(66);\n\nexports.Ring = Ring;\n\nvar Polygon = __webpack_require__(67);\n\nexports.Polygon = Polygon;\n\nvar Polyline = __webpack_require__(70);\n\nexports.Polyline = Polyline;\n\nvar Rect = __webpack_require__(71);\n\nexports.Rect = Rect;\n\nvar Line = __webpack_require__(72);\n\nexports.Line = Line;\n\nvar BezierCurve = __webpack_require__(73);\n\nexports.BezierCurve = BezierCurve;\n\nvar Arc = __webpack_require__(74);\n\nexports.Arc = Arc;\n\nvar CompoundPath = __webpack_require__(75);\n\nexports.CompoundPath = CompoundPath;\n\nvar LinearGradient = __webpack_require__(76);\n\nexports.LinearGradient = LinearGradient;\n\nvar RadialGradient = __webpack_require__(77);\n\nexports.RadialGradient = RadialGradient;\n\nvar BoundingRect = __webpack_require__(3);\n\nexports.BoundingRect = BoundingRect;\n\nvar IncrementalDisplayable = __webpack_require__(78);\n\nexports.IncrementalDisplayable = IncrementalDisplayable;\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\nvar round = Math.round;\nvar mathMax = Math.max;\nvar mathMin = Math.min;\nvar EMPTY_OBJ = {};\nvar Z2_EMPHASIS_LIFT = 1;\n/**\n * Extend shape with parameters\n */\n\nfunction extendShape(opts) {\n  return Path.extend(opts);\n}\n/**\n * Extend path\n */\n\n\nfunction extendPath(pathData, opts) {\n  return pathTool.extendFromString(pathData, opts);\n}\n/**\n * Create a path element from path data string\n * @param {string} pathData\n * @param {Object} opts\n * @param {module:zrender/core/BoundingRect} rect\n * @param {string} [layout=cover] 'center' or 'cover'\n */\n\n\nfunction makePath(pathData, opts, rect, layout) {\n  var path = pathTool.createFromString(pathData, opts);\n\n  if (rect) {\n    if (layout === 'center') {\n      rect = centerGraphic(rect, path.getBoundingRect());\n    }\n\n    resizePath(path, rect);\n  }\n\n  return path;\n}\n/**\n * Create a image element from image url\n * @param {string} imageUrl image url\n * @param {Object} opts options\n * @param {module:zrender/core/BoundingRect} rect constrain rect\n * @param {string} [layout=cover] 'center' or 'cover'\n */\n\n\nfunction makeImage(imageUrl, rect, layout) {\n  var path = new ZImage({\n    style: {\n      image: imageUrl,\n      x: rect.x,\n      y: rect.y,\n      width: rect.width,\n      height: rect.height\n    },\n    onload: function (img) {\n      if (layout === 'center') {\n        var boundingRect = {\n          width: img.width,\n          height: img.height\n        };\n        path.setStyle(centerGraphic(rect, boundingRect));\n      }\n    }\n  });\n  return path;\n}\n/**\n * Get position of centered element in bounding box.\n *\n * @param  {Object} rect         element local bounding box\n * @param  {Object} boundingRect constraint bounding box\n * @return {Object} element position containing x, y, width, and height\n */\n\n\nfunction centerGraphic(rect, boundingRect) {\n  // Set rect to center, keep width / height ratio.\n  var aspect = boundingRect.width / boundingRect.height;\n  var width = rect.height * aspect;\n  var height;\n\n  if (width <= rect.width) {\n    height = rect.height;\n  } else {\n    width = rect.width;\n    height = width / aspect;\n  }\n\n  var cx = rect.x + rect.width / 2;\n  var cy = rect.y + rect.height / 2;\n  return {\n    x: cx - width / 2,\n    y: cy - height / 2,\n    width: width,\n    height: height\n  };\n}\n\nvar mergePath = pathTool.mergePath;\n/**\n * Resize a path to fit the rect\n * @param {module:zrender/graphic/Path} path\n * @param {Object} rect\n */\n\nfunction resizePath(path, rect) {\n  if (!path.applyTransform) {\n    return;\n  }\n\n  var pathRect = path.getBoundingRect();\n  var m = pathRect.calculateTransform(rect);\n  path.applyTransform(m);\n}\n/**\n * Sub pixel optimize line for canvas\n *\n * @param {Object} param\n * @param {Object} [param.shape]\n * @param {number} [param.shape.x1]\n * @param {number} [param.shape.y1]\n * @param {number} [param.shape.x2]\n * @param {number} [param.shape.y2]\n * @param {Object} [param.style]\n * @param {number} [param.style.lineWidth]\n * @return {Object} Modified param\n */\n\n\nfunction subPixelOptimizeLine(param) {\n  var shape = param.shape;\n  var lineWidth = param.style.lineWidth;\n\n  if (round(shape.x1 * 2) === round(shape.x2 * 2)) {\n    shape.x1 = shape.x2 = subPixelOptimize(shape.x1, lineWidth, true);\n  }\n\n  if (round(shape.y1 * 2) === round(shape.y2 * 2)) {\n    shape.y1 = shape.y2 = subPixelOptimize(shape.y1, lineWidth, true);\n  }\n\n  return param;\n}\n/**\n * Sub pixel optimize rect for canvas\n *\n * @param {Object} param\n * @param {Object} [param.shape]\n * @param {number} [param.shape.x]\n * @param {number} [param.shape.y]\n * @param {number} [param.shape.width]\n * @param {number} [param.shape.height]\n * @param {Object} [param.style]\n * @param {number} [param.style.lineWidth]\n * @return {Object} Modified param\n */\n\n\nfunction subPixelOptimizeRect(param) {\n  var shape = param.shape;\n  var lineWidth = param.style.lineWidth;\n  var originX = shape.x;\n  var originY = shape.y;\n  var originWidth = shape.width;\n  var originHeight = shape.height;\n  shape.x = subPixelOptimize(shape.x, lineWidth, true);\n  shape.y = subPixelOptimize(shape.y, lineWidth, true);\n  shape.width = Math.max(subPixelOptimize(originX + originWidth, lineWidth, false) - shape.x, originWidth === 0 ? 0 : 1);\n  shape.height = Math.max(subPixelOptimize(originY + originHeight, lineWidth, false) - shape.y, originHeight === 0 ? 0 : 1);\n  return param;\n}\n/**\n * Sub pixel optimize for canvas\n *\n * @param {number} position Coordinate, such as x, y\n * @param {number} lineWidth Should be nonnegative integer.\n * @param {boolean=} positiveOrNegative Default false (negative).\n * @return {number} Optimized position.\n */\n\n\nfunction subPixelOptimize(position, lineWidth, positiveOrNegative) {\n  // Assure that (position + lineWidth / 2) is near integer edge,\n  // otherwise line will be fuzzy in canvas.\n  var doubledPosition = round(position * 2);\n  return (doubledPosition + round(lineWidth)) % 2 === 0 ? doubledPosition / 2 : (doubledPosition + (positiveOrNegative ? 1 : -1)) / 2;\n}\n\nfunction hasFillOrStroke(fillOrStroke) {\n  return fillOrStroke != null && fillOrStroke !== 'none';\n} // Most lifted color are duplicated.\n\n\nvar liftedColorMap = zrUtil.createHashMap();\nvar liftedColorCount = 0;\n\nfunction liftColor(color) {\n  if (typeof color !== 'string') {\n    return color;\n  }\n\n  var liftedColor = liftedColorMap.get(color);\n\n  if (!liftedColor) {\n    liftedColor = colorTool.lift(color, -0.1);\n\n    if (liftedColorCount < 10000) {\n      liftedColorMap.set(color, liftedColor);\n      liftedColorCount++;\n    }\n  }\n\n  return liftedColor;\n}\n\nfunction cacheElementStl(el) {\n  if (!el.__hoverStlDirty) {\n    return;\n  }\n\n  el.__hoverStlDirty = false;\n  var hoverStyle = el.__hoverStl;\n\n  if (!hoverStyle) {\n    el.__cachedNormalStl = el.__cachedNormalZ2 = null;\n    return;\n  }\n\n  var normalStyle = el.__cachedNormalStl = {};\n  el.__cachedNormalZ2 = el.z2;\n  var elStyle = el.style;\n\n  for (var name in hoverStyle) {\n    // See comment in `doSingleEnterHover`.\n    if (hoverStyle[name] != null) {\n      normalStyle[name] = elStyle[name];\n    }\n  } // Always cache fill and stroke to normalStyle for lifting color.\n\n\n  normalStyle.fill = elStyle.fill;\n  normalStyle.stroke = elStyle.stroke;\n}\n\nfunction doSingleEnterHover(el) {\n  var hoverStl = el.__hoverStl;\n\n  if (!hoverStl || el.__highlighted) {\n    return;\n  }\n\n  var useHoverLayer = el.useHoverLayer;\n  el.__highlighted = useHoverLayer ? 'layer' : 'plain';\n  var zr = el.__zr;\n\n  if (!zr && useHoverLayer) {\n    return;\n  }\n\n  var elTarget = el;\n  var targetStyle = el.style;\n\n  if (useHoverLayer) {\n    elTarget = zr.addHover(el);\n    targetStyle = elTarget.style;\n  }\n\n  rollbackDefaultTextStyle(targetStyle);\n\n  if (!useHoverLayer) {\n    cacheElementStl(elTarget);\n  } // styles can be:\n  // {\n  //    label: {\n  //        show: false,\n  //        position: 'outside',\n  //        fontSize: 18\n  //    },\n  //    emphasis: {\n  //        label: {\n  //            show: true\n  //        }\n  //    }\n  // },\n  // where properties of `emphasis` may not appear in `normal`. We previously use\n  // module:echarts/util/model#defaultEmphasis to merge `normal` to `emphasis`.\n  // But consider rich text and setOption in merge mode, it is impossible to cover\n  // all properties in merge. So we use merge mode when setting style here, where\n  // only properties that is not `null/undefined` can be set. The disadventage:\n  // null/undefined can not be used to remove style any more in `emphasis`.\n\n\n  targetStyle.extendFrom(hoverStl);\n  setDefaultHoverFillStroke(targetStyle, hoverStl, 'fill');\n  setDefaultHoverFillStroke(targetStyle, hoverStl, 'stroke');\n  applyDefaultTextStyle(targetStyle);\n\n  if (!useHoverLayer) {\n    el.dirty(false);\n    el.z2 += Z2_EMPHASIS_LIFT;\n  }\n}\n\nfunction setDefaultHoverFillStroke(targetStyle, hoverStyle, prop) {\n  if (!hasFillOrStroke(hoverStyle[prop]) && hasFillOrStroke(targetStyle[prop])) {\n    targetStyle[prop] = liftColor(targetStyle[prop]);\n  }\n}\n\nfunction doSingleLeaveHover(el) {\n  var highlighted = el.__highlighted;\n\n  if (!highlighted) {\n    return;\n  }\n\n  el.__highlighted = false;\n\n  if (highlighted === 'layer') {\n    el.__zr && el.__zr.removeHover(el);\n  } else if (highlighted) {\n    var style = el.style;\n    var normalStl = el.__cachedNormalStl;\n\n    if (normalStl) {\n      rollbackDefaultTextStyle(style); // Consider null/undefined value, should use\n      // `setStyle` but not `extendFrom(stl, true)`.\n\n      el.setStyle(normalStl);\n      applyDefaultTextStyle(style);\n    } // `__cachedNormalZ2` will not be reset if calling `setElementHoverStyle`\n    // when `el` is on emphasis state. So here by comparing with 1, we try\n    // hard to make the bug case rare.\n\n\n    var normalZ2 = el.__cachedNormalZ2;\n\n    if (normalZ2 != null && el.z2 - normalZ2 === Z2_EMPHASIS_LIFT) {\n      el.z2 = normalZ2;\n    }\n  }\n}\n\nfunction traverseCall(el, method) {\n  el.isGroup ? el.traverse(function (child) {\n    !child.isGroup && method(child);\n  }) : method(el);\n}\n/**\n * Set hover style (namely \"emphasis style\") of element, based on the current\n * style of the given `el`.\n * This method should be called after all of the normal styles have been adopted\n * to the `el`. See the reason on `setHoverStyle`.\n *\n * @param {module:zrender/Element} el Should not be `zrender/container/Group`.\n * @param {Object|boolean} [hoverStl] The specified hover style.\n *        If set as `false`, disable the hover style.\n *        Similarly, The `el.hoverStyle` can alse be set\n *        as `false` to disable the hover style.\n *        Otherwise, use the default hover style if not provided.\n * @param {Object} [opt]\n * @param {boolean} [opt.hoverSilentOnTouch=false] See `graphic.setAsHoverStyleTrigger`\n */\n\n\nfunction setElementHoverStyle(el, hoverStl) {\n  // For performance consideration, it might be better to make the \"hover style\" only the\n  // difference properties from the \"normal style\", but not a entire copy of all styles.\n  hoverStl = el.__hoverStl = hoverStl !== false && (hoverStl || {});\n  el.__hoverStlDirty = true; // FIXME\n  // It is not completely right to save \"normal\"/\"emphasis\" flag on elements.\n  // It probably should be saved on `data` of series. Consider the cases:\n  // (1) A highlighted elements are moved out of the view port and re-enter\n  // again by dataZoom.\n  // (2) call `setOption` and replace elements totally when they are highlighted.\n\n  if (el.__highlighted) {\n    // Consider the case:\n    // The styles of a highlighted `el` is being updated. The new \"emphasis style\"\n    // should be adapted to the `el`. Notice here new \"normal styles\" should have\n    // been set outside and the cached \"normal style\" is out of date.\n    el.__cachedNormalStl = null; // Do not clear `__cachedNormalZ2` here, because setting `z2` is not a constraint\n    // of this method. In most cases, `z2` is not set and hover style should be able\n    // to rollback. Of course, that would bring bug, but only in a rare case, see\n    // `doSingleLeaveHover` for details.\n\n    doSingleLeaveHover(el);\n    doSingleEnterHover(el);\n  }\n}\n/**\n * Emphasis (called by API) has higher priority than `mouseover`.\n * When element has been called to be entered emphasis, mouse over\n * should not trigger the highlight effect (for example, animation\n * scale) again, and `mouseout` should not downplay the highlight\n * effect. So the listener of `mouseover` and `mouseout` should\n * check `isInEmphasis`.\n *\n * @param {module:zrender/Element} el\n * @return {boolean}\n */\n\n\nfunction isInEmphasis(el) {\n  return el && el.__isEmphasisEntered;\n}\n\nfunction onElementMouseOver(e) {\n  if (this.__hoverSilentOnTouch && e.zrByTouch) {\n    return;\n  } // Only if element is not in emphasis status\n\n\n  !this.__isEmphasisEntered && traverseCall(this, doSingleEnterHover);\n}\n\nfunction onElementMouseOut(e) {\n  if (this.__hoverSilentOnTouch && e.zrByTouch) {\n    return;\n  } // Only if element is not in emphasis status\n\n\n  !this.__isEmphasisEntered && traverseCall(this, doSingleLeaveHover);\n}\n\nfunction enterEmphasis() {\n  this.__isEmphasisEntered = true;\n  traverseCall(this, doSingleEnterHover);\n}\n\nfunction leaveEmphasis() {\n  this.__isEmphasisEntered = false;\n  traverseCall(this, doSingleLeaveHover);\n}\n/**\n * Set hover style (namely \"emphasis style\") of element,\n * based on the current style of the given `el`.\n *\n * (1)\n * **CONSTRAINTS** for this method:\n * <A> This method MUST be called after all of the normal styles having been adopted\n * to the `el`.\n * <B> The input `hoverStyle` (that is, \"emphasis style\") MUST be the subset of the\n * \"normal style\" having been set to the el.\n * <C> `color` MUST be one of the \"normal styles\" (because color might be lifted as\n * a default hover style).\n *\n * The reason: this method treat the current style of the `el` as the \"normal style\"\n * and cache them when enter/update the \"emphasis style\". Consider the case: the `el`\n * is in \"emphasis\" state and `setOption`/`dispatchAction` trigger the style updating\n * logic, where the el should shift from the original emphasis style to the new\n * \"emphasis style\" and should be able to \"downplay\" back to the new \"normal style\".\n *\n * Indeed, it is error-prone to make a interface has so many constraints, but I have\n * not found a better solution yet to fit the backward compatibility, performance and\n * the current programming style.\n *\n * (2)\n * Call the method for a \"root\" element once. Do not call it for each descendants.\n * If the descendants elemenets of a group has itself hover style different from the\n * root group, we can simply mount the style on `el.hoverStyle` for them, but should\n * not call this method for them.\n *\n * @param {module:zrender/Element} el\n * @param {Object|boolean} [hoverStyle] See `graphic.setElementHoverStyle`.\n * @param {Object} [opt]\n * @param {boolean} [opt.hoverSilentOnTouch=false] See `graphic.setAsHoverStyleTrigger`.\n */\n\n\nfunction setHoverStyle(el, hoverStyle, opt) {\n  el.isGroup ? el.traverse(function (child) {\n    // If element has sepcified hoverStyle, then use it instead of given hoverStyle\n    // Often used when item group has a label element and it's hoverStyle is different\n    !child.isGroup && setElementHoverStyle(child, child.hoverStyle || hoverStyle);\n  }) : setElementHoverStyle(el, el.hoverStyle || hoverStyle);\n  setAsHoverStyleTrigger(el, opt);\n}\n/**\n * @param {Object|boolean} [opt] If `false`, means disable trigger.\n * @param {boolean} [opt.hoverSilentOnTouch=false]\n *        In touch device, mouseover event will be trigger on touchstart event\n *        (see module:zrender/dom/HandlerProxy). By this mechanism, we can\n *        conveniently use hoverStyle when tap on touch screen without additional\n *        code for compatibility.\n *        But if the chart/component has select feature, which usually also use\n *        hoverStyle, there might be conflict between 'select-highlight' and\n *        'hover-highlight' especially when roam is enabled (see geo for example).\n *        In this case, hoverSilentOnTouch should be used to disable hover-highlight\n *        on touch device.\n */\n\n\nfunction setAsHoverStyleTrigger(el, opt) {\n  var disable = opt === false;\n  el.__hoverSilentOnTouch = opt != null && opt.hoverSilentOnTouch; // Simple optimize, since this method might be\n  // called for each elements of a group in some cases.\n\n  if (!disable || el.__hoverStyleTrigger) {\n    var method = disable ? 'off' : 'on'; // Duplicated function will be auto-ignored, see Eventful.js.\n\n    el[method]('mouseover', onElementMouseOver)[method]('mouseout', onElementMouseOut); // Emphasis, normal can be triggered manually\n\n    el[method]('emphasis', enterEmphasis)[method]('normal', leaveEmphasis);\n    el.__hoverStyleTrigger = !disable;\n  }\n}\n/**\n * See more info in `setTextStyleCommon`.\n * @param {Object|module:zrender/graphic/Style} normalStyle\n * @param {Object} emphasisStyle\n * @param {module:echarts/model/Model} normalModel\n * @param {module:echarts/model/Model} emphasisModel\n * @param {Object} opt Check `opt` of `setTextStyleCommon` to find other props.\n * @param {string|Function} [opt.defaultText]\n * @param {module:echarts/model/Model} [opt.labelFetcher] Fetch text by\n *      `opt.labelFetcher.getFormattedLabel(opt.labelDataIndex, 'normal'/'emphasis', null, opt.labelDimIndex)`\n * @param {module:echarts/model/Model} [opt.labelDataIndex] Fetch text by\n *      `opt.textFetcher.getFormattedLabel(opt.labelDataIndex, 'normal'/'emphasis', null, opt.labelDimIndex)`\n * @param {module:echarts/model/Model} [opt.labelDimIndex] Fetch text by\n *      `opt.textFetcher.getFormattedLabel(opt.labelDataIndex, 'normal'/'emphasis', null, opt.labelDimIndex)`\n * @param {Object} [normalSpecified]\n * @param {Object} [emphasisSpecified]\n */\n\n\nfunction setLabelStyle(normalStyle, emphasisStyle, normalModel, emphasisModel, opt, normalSpecified, emphasisSpecified) {\n  opt = opt || EMPTY_OBJ;\n  var labelFetcher = opt.labelFetcher;\n  var labelDataIndex = opt.labelDataIndex;\n  var labelDimIndex = opt.labelDimIndex; // This scenario, `label.normal.show = true; label.emphasis.show = false`,\n  // is not supported util someone requests.\n\n  var showNormal = normalModel.getShallow('show');\n  var showEmphasis = emphasisModel.getShallow('show'); // Consider performance, only fetch label when necessary.\n  // If `normal.show` is `false` and `emphasis.show` is `true` and `emphasis.formatter` is not set,\n  // label should be displayed, where text is fetched by `normal.formatter` or `opt.defaultText`.\n\n  var baseText;\n\n  if (showNormal || showEmphasis) {\n    if (labelFetcher) {\n      baseText = labelFetcher.getFormattedLabel(labelDataIndex, 'normal', null, labelDimIndex);\n    }\n\n    if (baseText == null) {\n      baseText = zrUtil.isFunction(opt.defaultText) ? opt.defaultText(labelDataIndex, opt) : opt.defaultText;\n    }\n  }\n\n  var normalStyleText = showNormal ? baseText : null;\n  var emphasisStyleText = showEmphasis ? zrUtil.retrieve2(labelFetcher ? labelFetcher.getFormattedLabel(labelDataIndex, 'emphasis', null, labelDimIndex) : null, baseText) : null; // Optimize: If style.text is null, text will not be drawn.\n\n  if (normalStyleText != null || emphasisStyleText != null) {\n    // Always set `textStyle` even if `normalStyle.text` is null, because default\n    // values have to be set on `normalStyle`.\n    // If we set default values on `emphasisStyle`, consider case:\n    // Firstly, `setOption(... label: {normal: {text: null}, emphasis: {show: true}} ...);`\n    // Secondly, `setOption(... label: {noraml: {show: true, text: 'abc', color: 'red'} ...);`\n    // Then the 'red' will not work on emphasis.\n    setTextStyle(normalStyle, normalModel, normalSpecified, opt);\n    setTextStyle(emphasisStyle, emphasisModel, emphasisSpecified, opt, true);\n  }\n\n  normalStyle.text = normalStyleText;\n  emphasisStyle.text = emphasisStyleText;\n}\n/**\n * Set basic textStyle properties.\n * See more info in `setTextStyleCommon`.\n * @param {Object|module:zrender/graphic/Style} textStyle\n * @param {module:echarts/model/Model} model\n * @param {Object} [specifiedTextStyle] Can be overrided by settings in model.\n * @param {Object} [opt] See `opt` of `setTextStyleCommon`.\n * @param {boolean} [isEmphasis]\n */\n\n\nfunction setTextStyle(textStyle, textStyleModel, specifiedTextStyle, opt, isEmphasis) {\n  setTextStyleCommon(textStyle, textStyleModel, opt, isEmphasis);\n  specifiedTextStyle && zrUtil.extend(textStyle, specifiedTextStyle); // textStyle.host && textStyle.host.dirty && textStyle.host.dirty(false);\n\n  return textStyle;\n}\n/**\n * Set text option in the style.\n * See more info in `setTextStyleCommon`.\n * @deprecated\n * @param {Object} textStyle\n * @param {module:echarts/model/Model} labelModel\n * @param {string|boolean} defaultColor Default text color.\n *        If set as false, it will be processed as a emphasis style.\n */\n\n\nfunction setText(textStyle, labelModel, defaultColor) {\n  var opt = {\n    isRectText: true\n  };\n  var isEmphasis;\n\n  if (defaultColor === false) {\n    isEmphasis = true;\n  } else {\n    // Support setting color as 'auto' to get visual color.\n    opt.autoColor = defaultColor;\n  }\n\n  setTextStyleCommon(textStyle, labelModel, opt, isEmphasis); // textStyle.host && textStyle.host.dirty && textStyle.host.dirty(false);\n}\n/**\n * The uniform entry of set text style, that is, retrieve style definitions\n * from `model` and set to `textStyle` object.\n *\n * Never in merge mode, but in overwrite mode, that is, all of the text style\n * properties will be set. (Consider the states of normal and emphasis and\n * default value can be adopted, merge would make the logic too complicated\n * to manage.)\n *\n * The `textStyle` object can either be a plain object or an instance of\n * `zrender/src/graphic/Style`, and either be the style of normal or emphasis.\n * After this mothod called, the `textStyle` object can then be used in\n * `el.setStyle(textStyle)` or `el.hoverStyle = textStyle`.\n *\n * Default value will be adopted and `insideRollbackOpt` will be created.\n * See `applyDefaultTextStyle` `rollbackDefaultTextStyle` for more details.\n *\n * opt: {\n *      disableBox: boolean, Whether diable drawing box of block (outer most).\n *      isRectText: boolean,\n *      autoColor: string, specify a color when color is 'auto',\n *              for textFill, textStroke, textBackgroundColor, and textBorderColor.\n *              If autoColor specified, it is used as default textFill.\n *      useInsideStyle:\n *              `true`: Use inside style (textFill, textStroke, textStrokeWidth)\n *                  if `textFill` is not specified.\n *              `false`: Do not use inside style.\n *              `null/undefined`: use inside style if `isRectText` is true and\n *                  `textFill` is not specified and textPosition contains `'inside'`.\n *      forceRich: boolean\n * }\n */\n\n\nfunction setTextStyleCommon(textStyle, textStyleModel, opt, isEmphasis) {\n  // Consider there will be abnormal when merge hover style to normal style if given default value.\n  opt = opt || EMPTY_OBJ;\n\n  if (opt.isRectText) {\n    var textPosition = textStyleModel.getShallow('position') || (isEmphasis ? null : 'inside'); // 'outside' is not a valid zr textPostion value, but used\n    // in bar series, and magric type should be considered.\n\n    textPosition === 'outside' && (textPosition = 'top');\n    textStyle.textPosition = textPosition;\n    textStyle.textOffset = textStyleModel.getShallow('offset');\n    var labelRotate = textStyleModel.getShallow('rotate');\n    labelRotate != null && (labelRotate *= Math.PI / 180);\n    textStyle.textRotation = labelRotate;\n    textStyle.textDistance = zrUtil.retrieve2(textStyleModel.getShallow('distance'), isEmphasis ? null : 5);\n  }\n\n  var ecModel = textStyleModel.ecModel;\n  var globalTextStyle = ecModel && ecModel.option.textStyle; // Consider case:\n  // {\n  //     data: [{\n  //         value: 12,\n  //         label: {\n  //             rich: {\n  //                 // no 'a' here but using parent 'a'.\n  //             }\n  //         }\n  //     }],\n  //     rich: {\n  //         a: { ... }\n  //     }\n  // }\n\n  var richItemNames = getRichItemNames(textStyleModel);\n  var richResult;\n\n  if (richItemNames) {\n    richResult = {};\n\n    for (var name in richItemNames) {\n      if (richItemNames.hasOwnProperty(name)) {\n        // Cascade is supported in rich.\n        var richTextStyle = textStyleModel.getModel(['rich', name]); // In rich, never `disableBox`.\n\n        setTokenTextStyle(richResult[name] = {}, richTextStyle, globalTextStyle, opt, isEmphasis);\n      }\n    }\n  }\n\n  textStyle.rich = richResult;\n  setTokenTextStyle(textStyle, textStyleModel, globalTextStyle, opt, isEmphasis, true);\n\n  if (opt.forceRich && !opt.textStyle) {\n    opt.textStyle = {};\n  }\n\n  return textStyle;\n} // Consider case:\n// {\n//     data: [{\n//         value: 12,\n//         label: {\n//             rich: {\n//                 // no 'a' here but using parent 'a'.\n//             }\n//         }\n//     }],\n//     rich: {\n//         a: { ... }\n//     }\n// }\n\n\nfunction getRichItemNames(textStyleModel) {\n  // Use object to remove duplicated names.\n  var richItemNameMap;\n\n  while (textStyleModel && textStyleModel !== textStyleModel.ecModel) {\n    var rich = (textStyleModel.option || EMPTY_OBJ).rich;\n\n    if (rich) {\n      richItemNameMap = richItemNameMap || {};\n\n      for (var name in rich) {\n        if (rich.hasOwnProperty(name)) {\n          richItemNameMap[name] = 1;\n        }\n      }\n    }\n\n    textStyleModel = textStyleModel.parentModel;\n  }\n\n  return richItemNameMap;\n}\n\nfunction setTokenTextStyle(textStyle, textStyleModel, globalTextStyle, opt, isEmphasis, isBlock) {\n  // In merge mode, default value should not be given.\n  globalTextStyle = !isEmphasis && globalTextStyle || EMPTY_OBJ;\n  textStyle.textFill = getAutoColor(textStyleModel.getShallow('color'), opt) || globalTextStyle.color;\n  textStyle.textStroke = getAutoColor(textStyleModel.getShallow('textBorderColor'), opt) || globalTextStyle.textBorderColor;\n  textStyle.textStrokeWidth = zrUtil.retrieve2(textStyleModel.getShallow('textBorderWidth'), globalTextStyle.textBorderWidth); // Save original textPosition, because style.textPosition will be repalced by\n  // real location (like [10, 30]) in zrender.\n\n  textStyle.insideRawTextPosition = textStyle.textPosition;\n\n  if (!isEmphasis) {\n    if (isBlock) {\n      textStyle.insideRollbackOpt = opt;\n      applyDefaultTextStyle(textStyle);\n    } // Set default finally.\n\n\n    if (textStyle.textFill == null) {\n      textStyle.textFill = opt.autoColor;\n    }\n  } // Do not use `getFont` here, because merge should be supported, where\n  // part of these properties may be changed in emphasis style, and the\n  // others should remain their original value got from normal style.\n\n\n  textStyle.fontStyle = textStyleModel.getShallow('fontStyle') || globalTextStyle.fontStyle;\n  textStyle.fontWeight = textStyleModel.getShallow('fontWeight') || globalTextStyle.fontWeight;\n  textStyle.fontSize = textStyleModel.getShallow('fontSize') || globalTextStyle.fontSize;\n  textStyle.fontFamily = textStyleModel.getShallow('fontFamily') || globalTextStyle.fontFamily;\n  textStyle.textAlign = textStyleModel.getShallow('align');\n  textStyle.textVerticalAlign = textStyleModel.getShallow('verticalAlign') || textStyleModel.getShallow('baseline');\n  textStyle.textLineHeight = textStyleModel.getShallow('lineHeight');\n  textStyle.textWidth = textStyleModel.getShallow('width');\n  textStyle.textHeight = textStyleModel.getShallow('height');\n  textStyle.textTag = textStyleModel.getShallow('tag');\n\n  if (!isBlock || !opt.disableBox) {\n    textStyle.textBackgroundColor = getAutoColor(textStyleModel.getShallow('backgroundColor'), opt);\n    textStyle.textPadding = textStyleModel.getShallow('padding');\n    textStyle.textBorderColor = getAutoColor(textStyleModel.getShallow('borderColor'), opt);\n    textStyle.textBorderWidth = textStyleModel.getShallow('borderWidth');\n    textStyle.textBorderRadius = textStyleModel.getShallow('borderRadius');\n    textStyle.textBoxShadowColor = textStyleModel.getShallow('shadowColor');\n    textStyle.textBoxShadowBlur = textStyleModel.getShallow('shadowBlur');\n    textStyle.textBoxShadowOffsetX = textStyleModel.getShallow('shadowOffsetX');\n    textStyle.textBoxShadowOffsetY = textStyleModel.getShallow('shadowOffsetY');\n  }\n\n  textStyle.textShadowColor = textStyleModel.getShallow('textShadowColor') || globalTextStyle.textShadowColor;\n  textStyle.textShadowBlur = textStyleModel.getShallow('textShadowBlur') || globalTextStyle.textShadowBlur;\n  textStyle.textShadowOffsetX = textStyleModel.getShallow('textShadowOffsetX') || globalTextStyle.textShadowOffsetX;\n  textStyle.textShadowOffsetY = textStyleModel.getShallow('textShadowOffsetY') || globalTextStyle.textShadowOffsetY;\n}\n\nfunction getAutoColor(color, opt) {\n  return color !== 'auto' ? color : opt && opt.autoColor ? opt.autoColor : null;\n}\n/**\n * Give some default value to the input `textStyle` object, based on the current settings\n * in this `textStyle` object.\n *\n * The Scenario:\n * when text position is `inside` and `textFill` is not specified, we show\n * text border by default for better view. But it should be considered that text position\n * might be changed when hovering or being emphasis, where the `insideRollback` is used to\n * restore the style.\n *\n * Usage (& NOTICE):\n * When a style object (eithor plain object or instance of `zrender/src/graphic/Style`) is\n * about to be modified on its text related properties, `rollbackDefaultTextStyle` should\n * be called before the modification and `applyDefaultTextStyle` should be called after that.\n * (For the case that all of the text related properties is reset, like `setTextStyleCommon`\n * does, `rollbackDefaultTextStyle` is not needed to be called).\n */\n\n\nfunction applyDefaultTextStyle(textStyle) {\n  var opt = textStyle.insideRollbackOpt; // Only `insideRollbackOpt` created (in `setTextStyleCommon`),\n  // applyDefaultTextStyle works.\n\n  if (!opt || textStyle.textFill != null) {\n    return;\n  }\n\n  var useInsideStyle = opt.useInsideStyle;\n  var textPosition = textStyle.insideRawTextPosition;\n  var insideRollback;\n  var autoColor = opt.autoColor;\n\n  if (useInsideStyle !== false && (useInsideStyle === true || opt.isRectText && textPosition // textPosition can be [10, 30]\n  && typeof textPosition === 'string' && textPosition.indexOf('inside') >= 0)) {\n    insideRollback = {\n      textFill: null,\n      textStroke: textStyle.textStroke,\n      textStrokeWidth: textStyle.textStrokeWidth\n    };\n    textStyle.textFill = '#fff'; // Consider text with #fff overflow its container.\n\n    if (textStyle.textStroke == null) {\n      textStyle.textStroke = autoColor;\n      textStyle.textStrokeWidth == null && (textStyle.textStrokeWidth = 2);\n    }\n  } else if (autoColor != null) {\n    insideRollback = {\n      textFill: null\n    };\n    textStyle.textFill = autoColor;\n  } // Always set `insideRollback`, for clearing previous.\n\n\n  if (insideRollback) {\n    textStyle.insideRollback = insideRollback;\n  }\n}\n/**\n * Consider the case: in a scatter,\n * label: {\n *     normal: {position: 'inside'},\n *     emphasis: {position: 'top'}\n * }\n * In the normal state, the `textFill` will be set as '#fff' for pretty view (see\n * `applyDefaultTextStyle`), but when switching to emphasis state, the `textFill`\n * should be retured to 'autoColor', but not keep '#fff'.\n */\n\n\nfunction rollbackDefaultTextStyle(style) {\n  var insideRollback = style.insideRollback;\n\n  if (insideRollback) {\n    style.textFill = insideRollback.textFill;\n    style.textStroke = insideRollback.textStroke;\n    style.textStrokeWidth = insideRollback.textStrokeWidth;\n    style.insideRollback = null;\n  }\n}\n\nfunction getFont(opt, ecModel) {\n  // ecModel or default text style model.\n  var gTextStyleModel = ecModel || ecModel.getModel('textStyle');\n  return zrUtil.trim([// FIXME in node-canvas fontWeight is before fontStyle\n  opt.fontStyle || gTextStyleModel && gTextStyleModel.getShallow('fontStyle') || '', opt.fontWeight || gTextStyleModel && gTextStyleModel.getShallow('fontWeight') || '', (opt.fontSize || gTextStyleModel && gTextStyleModel.getShallow('fontSize') || 12) + 'px', opt.fontFamily || gTextStyleModel && gTextStyleModel.getShallow('fontFamily') || 'sans-serif'].join(' '));\n}\n\nfunction animateOrSetProps(isUpdate, el, props, animatableModel, dataIndex, cb) {\n  if (typeof dataIndex === 'function') {\n    cb = dataIndex;\n    dataIndex = null;\n  } // Do not check 'animation' property directly here. Consider this case:\n  // animation model is an `itemModel`, whose does not have `isAnimationEnabled`\n  // but its parent model (`seriesModel`) does.\n\n\n  var animationEnabled = animatableModel && animatableModel.isAnimationEnabled();\n\n  if (animationEnabled) {\n    var postfix = isUpdate ? 'Update' : '';\n    var duration = animatableModel.getShallow('animationDuration' + postfix);\n    var animationEasing = animatableModel.getShallow('animationEasing' + postfix);\n    var animationDelay = animatableModel.getShallow('animationDelay' + postfix);\n\n    if (typeof animationDelay === 'function') {\n      animationDelay = animationDelay(dataIndex, animatableModel.getAnimationDelayParams ? animatableModel.getAnimationDelayParams(el, dataIndex) : null);\n    }\n\n    if (typeof duration === 'function') {\n      duration = duration(dataIndex);\n    }\n\n    duration > 0 ? el.animateTo(props, duration, animationDelay || 0, animationEasing, cb, !!cb) : (el.stopAnimation(), el.attr(props), cb && cb());\n  } else {\n    el.stopAnimation();\n    el.attr(props);\n    cb && cb();\n  }\n}\n/**\n * Update graphic element properties with or without animation according to the\n * configuration in series.\n *\n * Caution: this method will stop previous animation.\n * So if do not use this method to one element twice before\n * animation starts, unless you know what you are doing.\n *\n * @param {module:zrender/Element} el\n * @param {Object} props\n * @param {module:echarts/model/Model} [animatableModel]\n * @param {number} [dataIndex]\n * @param {Function} [cb]\n * @example\n *     graphic.updateProps(el, {\n *         position: [100, 100]\n *     }, seriesModel, dataIndex, function () { console.log('Animation done!'); });\n *     // Or\n *     graphic.updateProps(el, {\n *         position: [100, 100]\n *     }, seriesModel, function () { console.log('Animation done!'); });\n */\n\n\nfunction updateProps(el, props, animatableModel, dataIndex, cb) {\n  animateOrSetProps(true, el, props, animatableModel, dataIndex, cb);\n}\n/**\n * Init graphic element properties with or without animation according to the\n * configuration in series.\n *\n * Caution: this method will stop previous animation.\n * So if do not use this method to one element twice before\n * animation starts, unless you know what you are doing.\n *\n * @param {module:zrender/Element} el\n * @param {Object} props\n * @param {module:echarts/model/Model} [animatableModel]\n * @param {number} [dataIndex]\n * @param {Function} cb\n */\n\n\nfunction initProps(el, props, animatableModel, dataIndex, cb) {\n  animateOrSetProps(false, el, props, animatableModel, dataIndex, cb);\n}\n/**\n * Get transform matrix of target (param target),\n * in coordinate of its ancestor (param ancestor)\n *\n * @param {module:zrender/mixin/Transformable} target\n * @param {module:zrender/mixin/Transformable} [ancestor]\n */\n\n\nfunction getTransform(target, ancestor) {\n  var mat = matrix.identity([]);\n\n  while (target && target !== ancestor) {\n    matrix.mul(mat, target.getLocalTransform(), mat);\n    target = target.parent;\n  }\n\n  return mat;\n}\n/**\n * Apply transform to an vertex.\n * @param {Array.<number>} target [x, y]\n * @param {Array.<number>|TypedArray.<number>|Object} transform Can be:\n *      + Transform matrix: like [1, 0, 0, 1, 0, 0]\n *      + {position, rotation, scale}, the same as `zrender/Transformable`.\n * @param {boolean=} invert Whether use invert matrix.\n * @return {Array.<number>} [x, y]\n */\n\n\nfunction applyTransform(target, transform, invert) {\n  if (transform && !zrUtil.isArrayLike(transform)) {\n    transform = Transformable.getLocalTransform(transform);\n  }\n\n  if (invert) {\n    transform = matrix.invert([], transform);\n  }\n\n  return vector.applyTransform([], target, transform);\n}\n/**\n * @param {string} direction 'left' 'right' 'top' 'bottom'\n * @param {Array.<number>} transform Transform matrix: like [1, 0, 0, 1, 0, 0]\n * @param {boolean=} invert Whether use invert matrix.\n * @return {string} Transformed direction. 'left' 'right' 'top' 'bottom'\n */\n\n\nfunction transformDirection(direction, transform, invert) {\n  // Pick a base, ensure that transform result will not be (0, 0).\n  var hBase = transform[4] === 0 || transform[5] === 0 || transform[0] === 0 ? 1 : Math.abs(2 * transform[4] / transform[0]);\n  var vBase = transform[4] === 0 || transform[5] === 0 || transform[2] === 0 ? 1 : Math.abs(2 * transform[4] / transform[2]);\n  var vertex = [direction === 'left' ? -hBase : direction === 'right' ? hBase : 0, direction === 'top' ? -vBase : direction === 'bottom' ? vBase : 0];\n  vertex = applyTransform(vertex, transform, invert);\n  return Math.abs(vertex[0]) > Math.abs(vertex[1]) ? vertex[0] > 0 ? 'right' : 'left' : vertex[1] > 0 ? 'bottom' : 'top';\n}\n/**\n * Apply group transition animation from g1 to g2.\n * If no animatableModel, no animation.\n */\n\n\nfunction groupTransition(g1, g2, animatableModel, cb) {\n  if (!g1 || !g2) {\n    return;\n  }\n\n  function getElMap(g) {\n    var elMap = {};\n    g.traverse(function (el) {\n      if (!el.isGroup && el.anid) {\n        elMap[el.anid] = el;\n      }\n    });\n    return elMap;\n  }\n\n  function getAnimatableProps(el) {\n    var obj = {\n      position: vector.clone(el.position),\n      rotation: el.rotation\n    };\n\n    if (el.shape) {\n      obj.shape = zrUtil.extend({}, el.shape);\n    }\n\n    return obj;\n  }\n\n  var elMap1 = getElMap(g1);\n  g2.traverse(function (el) {\n    if (!el.isGroup && el.anid) {\n      var oldEl = elMap1[el.anid];\n\n      if (oldEl) {\n        var newProp = getAnimatableProps(el);\n        el.attr(getAnimatableProps(oldEl));\n        updateProps(el, newProp, animatableModel, el.dataIndex);\n      } // else {\n      //     if (el.previousProps) {\n      //         graphic.updateProps\n      //     }\n      // }\n\n    }\n  });\n}\n/**\n * @param {Array.<Array.<number>>} points Like: [[23, 44], [53, 66], ...]\n * @param {Object} rect {x, y, width, height}\n * @return {Array.<Array.<number>>} A new clipped points.\n */\n\n\nfunction clipPointsByRect(points, rect) {\n  // FIXME: this way migth be incorrect when grpahic clipped by a corner.\n  // and when element have border.\n  return zrUtil.map(points, function (point) {\n    var x = point[0];\n    x = mathMax(x, rect.x);\n    x = mathMin(x, rect.x + rect.width);\n    var y = point[1];\n    y = mathMax(y, rect.y);\n    y = mathMin(y, rect.y + rect.height);\n    return [x, y];\n  });\n}\n/**\n * @param {Object} targetRect {x, y, width, height}\n * @param {Object} rect {x, y, width, height}\n * @return {Object} A new clipped rect. If rect size are negative, return undefined.\n */\n\n\nfunction clipRectByRect(targetRect, rect) {\n  var x = mathMax(targetRect.x, rect.x);\n  var x2 = mathMin(targetRect.x + targetRect.width, rect.x + rect.width);\n  var y = mathMax(targetRect.y, rect.y);\n  var y2 = mathMin(targetRect.y + targetRect.height, rect.y + rect.height); // If the total rect is cliped, nothing, including the border,\n  // should be painted. So return undefined.\n\n  if (x2 >= x && y2 >= y) {\n    return {\n      x: x,\n      y: y,\n      width: x2 - x,\n      height: y2 - y\n    };\n  }\n}\n/**\n * @param {string} iconStr Support 'image://' or 'path://' or direct svg path.\n * @param {Object} [opt] Properties of `module:zrender/Element`, except `style`.\n * @param {Object} [rect] {x, y, width, height}\n * @return {module:zrender/Element} Icon path or image element.\n */\n\n\nfunction createIcon(iconStr, opt, rect) {\n  opt = zrUtil.extend({\n    rectHover: true\n  }, opt);\n  var style = opt.style = {\n    strokeNoScale: true\n  };\n  rect = rect || {\n    x: -1,\n    y: -1,\n    width: 2,\n    height: 2\n  };\n\n  if (iconStr) {\n    return iconStr.indexOf('image://') === 0 ? (style.image = iconStr.slice(8), zrUtil.defaults(style, rect), new ZImage(opt)) : makePath(iconStr.replace('path://', ''), opt, rect, 'center');\n  }\n}\n\nexports.Z2_EMPHASIS_LIFT = Z2_EMPHASIS_LIFT;\nexports.extendShape = extendShape;\nexports.extendPath = extendPath;\nexports.makePath = makePath;\nexports.makeImage = makeImage;\nexports.mergePath = mergePath;\nexports.resizePath = resizePath;\nexports.subPixelOptimizeLine = subPixelOptimizeLine;\nexports.subPixelOptimizeRect = subPixelOptimizeRect;\nexports.subPixelOptimize = subPixelOptimize;\nexports.setElementHoverStyle = setElementHoverStyle;\nexports.isInEmphasis = isInEmphasis;\nexports.setHoverStyle = setHoverStyle;\nexports.setAsHoverStyleTrigger = setAsHoverStyleTrigger;\nexports.setLabelStyle = setLabelStyle;\nexports.setTextStyle = setTextStyle;\nexports.setText = setText;\nexports.getFont = getFont;\nexports.updateProps = updateProps;\nexports.initProps = initProps;\nexports.getTransform = getTransform;\nexports.applyTransform = applyTransform;\nexports.transformDirection = transformDirection;\nexports.groupTransition = groupTransition;\nexports.clipPointsByRect = clipPointsByRect;\nexports.clipRectByRect = clipRectByRect;\nexports.createIcon = createIcon;\n\n/***/ }),\n/* 41 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar Path = __webpack_require__(1);\n\nvar PathProxy = __webpack_require__(9);\n\nvar transformPath = __webpack_require__(59);\n\n// command chars\n// var cc = [\n//     'm', 'M', 'l', 'L', 'v', 'V', 'h', 'H', 'z', 'Z',\n//     'c', 'C', 'q', 'Q', 't', 'T', 's', 'S', 'a', 'A'\n// ];\nvar mathSqrt = Math.sqrt;\nvar mathSin = Math.sin;\nvar mathCos = Math.cos;\nvar PI = Math.PI;\n\nvar vMag = function (v) {\n  return Math.sqrt(v[0] * v[0] + v[1] * v[1]);\n};\n\nvar vRatio = function (u, v) {\n  return (u[0] * v[0] + u[1] * v[1]) / (vMag(u) * vMag(v));\n};\n\nvar vAngle = function (u, v) {\n  return (u[0] * v[1] < u[1] * v[0] ? -1 : 1) * Math.acos(vRatio(u, v));\n};\n\nfunction processArc(x1, y1, x2, y2, fa, fs, rx, ry, psiDeg, cmd, path) {\n  var psi = psiDeg * (PI / 180.0);\n  var xp = mathCos(psi) * (x1 - x2) / 2.0 + mathSin(psi) * (y1 - y2) / 2.0;\n  var yp = -1 * mathSin(psi) * (x1 - x2) / 2.0 + mathCos(psi) * (y1 - y2) / 2.0;\n  var lambda = xp * xp / (rx * rx) + yp * yp / (ry * ry);\n\n  if (lambda > 1) {\n    rx *= mathSqrt(lambda);\n    ry *= mathSqrt(lambda);\n  }\n\n  var f = (fa === fs ? -1 : 1) * mathSqrt((rx * rx * (ry * ry) - rx * rx * (yp * yp) - ry * ry * (xp * xp)) / (rx * rx * (yp * yp) + ry * ry * (xp * xp))) || 0;\n  var cxp = f * rx * yp / ry;\n  var cyp = f * -ry * xp / rx;\n  var cx = (x1 + x2) / 2.0 + mathCos(psi) * cxp - mathSin(psi) * cyp;\n  var cy = (y1 + y2) / 2.0 + mathSin(psi) * cxp + mathCos(psi) * cyp;\n  var theta = vAngle([1, 0], [(xp - cxp) / rx, (yp - cyp) / ry]);\n  var u = [(xp - cxp) / rx, (yp - cyp) / ry];\n  var v = [(-1 * xp - cxp) / rx, (-1 * yp - cyp) / ry];\n  var dTheta = vAngle(u, v);\n\n  if (vRatio(u, v) <= -1) {\n    dTheta = PI;\n  }\n\n  if (vRatio(u, v) >= 1) {\n    dTheta = 0;\n  }\n\n  if (fs === 0 && dTheta > 0) {\n    dTheta = dTheta - 2 * PI;\n  }\n\n  if (fs === 1 && dTheta < 0) {\n    dTheta = dTheta + 2 * PI;\n  }\n\n  path.addData(cmd, cx, cy, rx, ry, theta, dTheta, psi, fs);\n}\n\nvar commandReg = /([mlvhzcqtsa])([^mlvhzcqtsa]*)/ig; // Consider case:\n// (1) delimiter can be comma or space, where continuous commas\n// or spaces should be seen as one comma.\n// (2) value can be like:\n// '2e-4', 'l.5.9' (ignore 0), 'M-10-10', 'l-2.43e-1,34.9983',\n// 'l-.5E1,54', '121-23-44-11' (no delimiter)\n\nvar numberReg = /-?([0-9]*\\.)?[0-9]+([eE]-?[0-9]+)?/g; // var valueSplitReg = /[\\s,]+/;\n\nfunction createPathProxyFromString(data) {\n  if (!data) {\n    return new PathProxy();\n  } // var data = data.replace(/-/g, ' -')\n  //     .replace(/  /g, ' ')\n  //     .replace(/ /g, ',')\n  //     .replace(/,,/g, ',');\n  // var n;\n  // create pipes so that we can split the data\n  // for (n = 0; n < cc.length; n++) {\n  //     cs = cs.replace(new RegExp(cc[n], 'g'), '|' + cc[n]);\n  // }\n  // data = data.replace(/-/g, ',-');\n  // create array\n  // var arr = cs.split('|');\n  // init context point\n\n\n  var cpx = 0;\n  var cpy = 0;\n  var subpathX = cpx;\n  var subpathY = cpy;\n  var prevCmd;\n  var path = new PathProxy();\n  var CMD = PathProxy.CMD; // commandReg.lastIndex = 0;\n  // var cmdResult;\n  // while ((cmdResult = commandReg.exec(data)) != null) {\n  //     var cmdStr = cmdResult[1];\n  //     var cmdContent = cmdResult[2];\n\n  var cmdList = data.match(commandReg);\n\n  for (var l = 0; l < cmdList.length; l++) {\n    var cmdText = cmdList[l];\n    var cmdStr = cmdText.charAt(0);\n    var cmd; // String#split is faster a little bit than String#replace or RegExp#exec.\n    // var p = cmdContent.split(valueSplitReg);\n    // var pLen = 0;\n    // for (var i = 0; i < p.length; i++) {\n    //     // '' and other invalid str => NaN\n    //     var val = parseFloat(p[i]);\n    //     !isNaN(val) && (p[pLen++] = val);\n    // }\n\n    var p = cmdText.match(numberReg) || [];\n    var pLen = p.length;\n\n    for (var i = 0; i < pLen; i++) {\n      p[i] = parseFloat(p[i]);\n    }\n\n    var off = 0;\n\n    while (off < pLen) {\n      var ctlPtx;\n      var ctlPty;\n      var rx;\n      var ry;\n      var psi;\n      var fa;\n      var fs;\n      var x1 = cpx;\n      var y1 = cpy; // convert l, H, h, V, and v to L\n\n      switch (cmdStr) {\n        case 'l':\n          cpx += p[off++];\n          cpy += p[off++];\n          cmd = CMD.L;\n          path.addData(cmd, cpx, cpy);\n          break;\n\n        case 'L':\n          cpx = p[off++];\n          cpy = p[off++];\n          cmd = CMD.L;\n          path.addData(cmd, cpx, cpy);\n          break;\n\n        case 'm':\n          cpx += p[off++];\n          cpy += p[off++];\n          cmd = CMD.M;\n          path.addData(cmd, cpx, cpy);\n          subpathX = cpx;\n          subpathY = cpy;\n          cmdStr = 'l';\n          break;\n\n        case 'M':\n          cpx = p[off++];\n          cpy = p[off++];\n          cmd = CMD.M;\n          path.addData(cmd, cpx, cpy);\n          subpathX = cpx;\n          subpathY = cpy;\n          cmdStr = 'L';\n          break;\n\n        case 'h':\n          cpx += p[off++];\n          cmd = CMD.L;\n          path.addData(cmd, cpx, cpy);\n          break;\n\n        case 'H':\n          cpx = p[off++];\n          cmd = CMD.L;\n          path.addData(cmd, cpx, cpy);\n          break;\n\n        case 'v':\n          cpy += p[off++];\n          cmd = CMD.L;\n          path.addData(cmd, cpx, cpy);\n          break;\n\n        case 'V':\n          cpy = p[off++];\n          cmd = CMD.L;\n          path.addData(cmd, cpx, cpy);\n          break;\n\n        case 'C':\n          cmd = CMD.C;\n          path.addData(cmd, p[off++], p[off++], p[off++], p[off++], p[off++], p[off++]);\n          cpx = p[off - 2];\n          cpy = p[off - 1];\n          break;\n\n        case 'c':\n          cmd = CMD.C;\n          path.addData(cmd, p[off++] + cpx, p[off++] + cpy, p[off++] + cpx, p[off++] + cpy, p[off++] + cpx, p[off++] + cpy);\n          cpx += p[off - 2];\n          cpy += p[off - 1];\n          break;\n\n        case 'S':\n          ctlPtx = cpx;\n          ctlPty = cpy;\n          var len = path.len();\n          var pathData = path.data;\n\n          if (prevCmd === CMD.C) {\n            ctlPtx += cpx - pathData[len - 4];\n            ctlPty += cpy - pathData[len - 3];\n          }\n\n          cmd = CMD.C;\n          x1 = p[off++];\n          y1 = p[off++];\n          cpx = p[off++];\n          cpy = p[off++];\n          path.addData(cmd, ctlPtx, ctlPty, x1, y1, cpx, cpy);\n          break;\n\n        case 's':\n          ctlPtx = cpx;\n          ctlPty = cpy;\n          var len = path.len();\n          var pathData = path.data;\n\n          if (prevCmd === CMD.C) {\n            ctlPtx += cpx - pathData[len - 4];\n            ctlPty += cpy - pathData[len - 3];\n          }\n\n          cmd = CMD.C;\n          x1 = cpx + p[off++];\n          y1 = cpy + p[off++];\n          cpx += p[off++];\n          cpy += p[off++];\n          path.addData(cmd, ctlPtx, ctlPty, x1, y1, cpx, cpy);\n          break;\n\n        case 'Q':\n          x1 = p[off++];\n          y1 = p[off++];\n          cpx = p[off++];\n          cpy = p[off++];\n          cmd = CMD.Q;\n          path.addData(cmd, x1, y1, cpx, cpy);\n          break;\n\n        case 'q':\n          x1 = p[off++] + cpx;\n          y1 = p[off++] + cpy;\n          cpx += p[off++];\n          cpy += p[off++];\n          cmd = CMD.Q;\n          path.addData(cmd, x1, y1, cpx, cpy);\n          break;\n\n        case 'T':\n          ctlPtx = cpx;\n          ctlPty = cpy;\n          var len = path.len();\n          var pathData = path.data;\n\n          if (prevCmd === CMD.Q) {\n            ctlPtx += cpx - pathData[len - 4];\n            ctlPty += cpy - pathData[len - 3];\n          }\n\n          cpx = p[off++];\n          cpy = p[off++];\n          cmd = CMD.Q;\n          path.addData(cmd, ctlPtx, ctlPty, cpx, cpy);\n          break;\n\n        case 't':\n          ctlPtx = cpx;\n          ctlPty = cpy;\n          var len = path.len();\n          var pathData = path.data;\n\n          if (prevCmd === CMD.Q) {\n            ctlPtx += cpx - pathData[len - 4];\n            ctlPty += cpy - pathData[len - 3];\n          }\n\n          cpx += p[off++];\n          cpy += p[off++];\n          cmd = CMD.Q;\n          path.addData(cmd, ctlPtx, ctlPty, cpx, cpy);\n          break;\n\n        case 'A':\n          rx = p[off++];\n          ry = p[off++];\n          psi = p[off++];\n          fa = p[off++];\n          fs = p[off++];\n          x1 = cpx, y1 = cpy;\n          cpx = p[off++];\n          cpy = p[off++];\n          cmd = CMD.A;\n          processArc(x1, y1, cpx, cpy, fa, fs, rx, ry, psi, cmd, path);\n          break;\n\n        case 'a':\n          rx = p[off++];\n          ry = p[off++];\n          psi = p[off++];\n          fa = p[off++];\n          fs = p[off++];\n          x1 = cpx, y1 = cpy;\n          cpx += p[off++];\n          cpy += p[off++];\n          cmd = CMD.A;\n          processArc(x1, y1, cpx, cpy, fa, fs, rx, ry, psi, cmd, path);\n          break;\n      }\n    }\n\n    if (cmdStr === 'z' || cmdStr === 'Z') {\n      cmd = CMD.Z;\n      path.addData(cmd); // z may be in the middle of the path.\n\n      cpx = subpathX;\n      cpy = subpathY;\n    }\n\n    prevCmd = cmd;\n  }\n\n  path.toStatic();\n  return path;\n} // TODO Optimize double memory cost problem\n\n\nfunction createPathOptions(str, opts) {\n  var pathProxy = createPathProxyFromString(str);\n  opts = opts || {};\n\n  opts.buildPath = function (path) {\n    if (path.setData) {\n      path.setData(pathProxy.data); // Svg and vml renderer don't have context\n\n      var ctx = path.getContext();\n\n      if (ctx) {\n        path.rebuildPath(ctx);\n      }\n    } else {\n      var ctx = path;\n      pathProxy.rebuildPath(ctx);\n    }\n  };\n\n  opts.applyTransform = function (m) {\n    transformPath(pathProxy, m);\n    this.dirty(true);\n  };\n\n  return opts;\n}\n/**\n * Create a Path object from path string data\n * http://www.w3.org/TR/SVG/paths.html#PathData\n * @param  {Object} opts Other options\n */\n\n\nfunction createFromString(str, opts) {\n  return new Path(createPathOptions(str, opts));\n}\n/**\n * Create a Path class from path string data\n * @param  {string} str\n * @param  {Object} opts Other options\n */\n\n\nfunction extendFromString(str, opts) {\n  return Path.extend(createPathOptions(str, opts));\n}\n/**\n * Merge multiple paths\n */\n// TODO Apply transform\n// TODO stroke dash\n// TODO Optimize double memory cost problem\n\n\nfunction mergePath(pathEls, opts) {\n  var pathList = [];\n  var len = pathEls.length;\n\n  for (var i = 0; i < len; i++) {\n    var pathEl = pathEls[i];\n\n    if (!pathEl.path) {\n      pathEl.createPathProxy();\n    }\n\n    if (pathEl.__dirtyPath) {\n      pathEl.buildPath(pathEl.path, pathEl.shape, true);\n    }\n\n    pathList.push(pathEl.path);\n  }\n\n  var pathBundle = new Path(opts); // Need path proxy.\n\n  pathBundle.createPathProxy();\n\n  pathBundle.buildPath = function (path) {\n    path.appendPath(pathList); // Svg and vml renderer don't have context\n\n    var ctx = path.getContext();\n\n    if (ctx) {\n      path.rebuildPath(ctx);\n    }\n  };\n\n  return pathBundle;\n}\n\nexports.createFromString = createFromString;\nexports.extendFromString = extendFromString;\nexports.mergePath = mergePath;\n\n/***/ }),\n/* 42 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar fixShadow = __webpack_require__(16);\n\nvar _constant = __webpack_require__(8);\n\nvar ContextCachedBy = _constant.ContextCachedBy;\nvar STYLE_COMMON_PROPS = [['shadowBlur', 0], ['shadowOffsetX', 0], ['shadowOffsetY', 0], ['shadowColor', '#000'], ['lineCap', 'butt'], ['lineJoin', 'miter'], ['miterLimit', 10]]; // var SHADOW_PROPS = STYLE_COMMON_PROPS.slice(0, 4);\n// var LINE_PROPS = STYLE_COMMON_PROPS.slice(4);\n\nvar Style = function (opts) {\n  this.extendFrom(opts, false);\n};\n\nfunction createLinearGradient(ctx, obj, rect) {\n  var x = obj.x == null ? 0 : obj.x;\n  var x2 = obj.x2 == null ? 1 : obj.x2;\n  var y = obj.y == null ? 0 : obj.y;\n  var y2 = obj.y2 == null ? 0 : obj.y2;\n\n  if (!obj.global) {\n    x = x * rect.width + rect.x;\n    x2 = x2 * rect.width + rect.x;\n    y = y * rect.height + rect.y;\n    y2 = y2 * rect.height + rect.y;\n  } // Fix NaN when rect is Infinity\n\n\n  x = isNaN(x) ? 0 : x;\n  x2 = isNaN(x2) ? 1 : x2;\n  y = isNaN(y) ? 0 : y;\n  y2 = isNaN(y2) ? 0 : y2;\n  var canvasGradient = ctx.createLinearGradient(x, y, x2, y2);\n  return canvasGradient;\n}\n\nfunction createRadialGradient(ctx, obj, rect) {\n  var width = rect.width;\n  var height = rect.height;\n  var min = Math.min(width, height);\n  var x = obj.x == null ? 0.5 : obj.x;\n  var y = obj.y == null ? 0.5 : obj.y;\n  var r = obj.r == null ? 0.5 : obj.r;\n\n  if (!obj.global) {\n    x = x * width + rect.x;\n    y = y * height + rect.y;\n    r = r * min;\n  }\n\n  var canvasGradient = ctx.createRadialGradient(x, y, 0, x, y, r);\n  return canvasGradient;\n}\n\nStyle.prototype = {\n  constructor: Style,\n\n  /**\n   * @type {string}\n   */\n  fill: '#000',\n\n  /**\n   * @type {string}\n   */\n  stroke: null,\n\n  /**\n   * @type {number}\n   */\n  opacity: 1,\n\n  /**\n   * @type {number}\n   */\n  fillOpacity: null,\n\n  /**\n   * @type {number}\n   */\n  strokeOpacity: null,\n\n  /**\n   * @type {Array.<number>}\n   */\n  lineDash: null,\n\n  /**\n   * @type {number}\n   */\n  lineDashOffset: 0,\n\n  /**\n   * @type {number}\n   */\n  shadowBlur: 0,\n\n  /**\n   * @type {number}\n   */\n  shadowOffsetX: 0,\n\n  /**\n   * @type {number}\n   */\n  shadowOffsetY: 0,\n\n  /**\n   * @type {number}\n   */\n  lineWidth: 1,\n\n  /**\n   * If stroke ignore scale\n   * @type {Boolean}\n   */\n  strokeNoScale: false,\n  // Bounding rect text configuration\n  // Not affected by element transform\n\n  /**\n   * @type {string}\n   */\n  text: null,\n\n  /**\n   * If `fontSize` or `fontFamily` exists, `font` will be reset by\n   * `fontSize`, `fontStyle`, `fontWeight`, `fontFamily`.\n   * So do not visit it directly in upper application (like echarts),\n   * but use `contain/text#makeFont` instead.\n   * @type {string}\n   */\n  font: null,\n\n  /**\n   * The same as font. Use font please.\n   * @deprecated\n   * @type {string}\n   */\n  textFont: null,\n\n  /**\n   * It helps merging respectively, rather than parsing an entire font string.\n   * @type {string}\n   */\n  fontStyle: null,\n\n  /**\n   * It helps merging respectively, rather than parsing an entire font string.\n   * @type {string}\n   */\n  fontWeight: null,\n\n  /**\n   * It helps merging respectively, rather than parsing an entire font string.\n   * Should be 12 but not '12px'.\n   * @type {number}\n   */\n  fontSize: null,\n\n  /**\n   * It helps merging respectively, rather than parsing an entire font string.\n   * @type {string}\n   */\n  fontFamily: null,\n\n  /**\n   * Reserved for special functinality, like 'hr'.\n   * @type {string}\n   */\n  textTag: null,\n\n  /**\n   * @type {string}\n   */\n  textFill: '#000',\n\n  /**\n   * @type {string}\n   */\n  textStroke: null,\n\n  /**\n   * @type {number}\n   */\n  textWidth: null,\n\n  /**\n   * Only for textBackground.\n   * @type {number}\n   */\n  textHeight: null,\n\n  /**\n   * textStroke may be set as some color as a default\n   * value in upper applicaion, where the default value\n   * of textStrokeWidth should be 0 to make sure that\n   * user can choose to do not use text stroke.\n   * @type {number}\n   */\n  textStrokeWidth: 0,\n\n  /**\n   * @type {number}\n   */\n  textLineHeight: null,\n\n  /**\n   * 'inside', 'left', 'right', 'top', 'bottom'\n   * [x, y]\n   * Based on x, y of rect.\n   * @type {string|Array.<number>}\n   * @default 'inside'\n   */\n  textPosition: 'inside',\n\n  /**\n   * If not specified, use the boundingRect of a `displayable`.\n   * @type {Object}\n   */\n  textRect: null,\n\n  /**\n   * [x, y]\n   * @type {Array.<number>}\n   */\n  textOffset: null,\n\n  /**\n   * @type {string}\n   */\n  textAlign: null,\n\n  /**\n   * @type {string}\n   */\n  textVerticalAlign: null,\n\n  /**\n   * @type {number}\n   */\n  textDistance: 5,\n\n  /**\n   * @type {string}\n   */\n  textShadowColor: 'transparent',\n\n  /**\n   * @type {number}\n   */\n  textShadowBlur: 0,\n\n  /**\n   * @type {number}\n   */\n  textShadowOffsetX: 0,\n\n  /**\n   * @type {number}\n   */\n  textShadowOffsetY: 0,\n\n  /**\n   * @type {string}\n   */\n  textBoxShadowColor: 'transparent',\n\n  /**\n   * @type {number}\n   */\n  textBoxShadowBlur: 0,\n\n  /**\n   * @type {number}\n   */\n  textBoxShadowOffsetX: 0,\n\n  /**\n   * @type {number}\n   */\n  textBoxShadowOffsetY: 0,\n\n  /**\n   * Whether transform text.\n   * Only useful in Path and Image element\n   * @type {boolean}\n   */\n  transformText: false,\n\n  /**\n   * Text rotate around position of Path or Image\n   * Only useful in Path and Image element and transformText is false.\n   */\n  textRotation: 0,\n\n  /**\n   * Text origin of text rotation, like [10, 40].\n   * Based on x, y of rect.\n   * Useful in label rotation of circular symbol.\n   * By default, this origin is textPosition.\n   * Can be 'center'.\n   * @type {string|Array.<number>}\n   */\n  textOrigin: null,\n\n  /**\n   * @type {string}\n   */\n  textBackgroundColor: null,\n\n  /**\n   * @type {string}\n   */\n  textBorderColor: null,\n\n  /**\n   * @type {number}\n   */\n  textBorderWidth: 0,\n\n  /**\n   * @type {number}\n   */\n  textBorderRadius: 0,\n\n  /**\n   * Can be `2` or `[2, 4]` or `[2, 3, 4, 5]`\n   * @type {number|Array.<number>}\n   */\n  textPadding: null,\n\n  /**\n   * Text styles for rich text.\n   * @type {Object}\n   */\n  rich: null,\n\n  /**\n   * {outerWidth, outerHeight, ellipsis, placeholder}\n   * @type {Object}\n   */\n  truncate: null,\n\n  /**\n   * https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/globalCompositeOperation\n   * @type {string}\n   */\n  blend: null,\n\n  /**\n   * @param {CanvasRenderingContext2D} ctx\n   */\n  bind: function (ctx, el, prevEl) {\n    var style = this;\n    var prevStyle = prevEl && prevEl.style; // If no prevStyle, it means first draw.\n    // Only apply cache if the last time cachced by this function.\n\n    var notCheckCache = !prevStyle || ctx.__attrCachedBy !== ContextCachedBy.STYLE_BIND;\n    ctx.__attrCachedBy = ContextCachedBy.STYLE_BIND;\n\n    for (var i = 0; i < STYLE_COMMON_PROPS.length; i++) {\n      var prop = STYLE_COMMON_PROPS[i];\n      var styleName = prop[0];\n\n      if (notCheckCache || style[styleName] !== prevStyle[styleName]) {\n        // FIXME Invalid property value will cause style leak from previous element.\n        ctx[styleName] = fixShadow(ctx, styleName, style[styleName] || prop[1]);\n      }\n    }\n\n    if (notCheckCache || style.fill !== prevStyle.fill) {\n      ctx.fillStyle = style.fill;\n    }\n\n    if (notCheckCache || style.stroke !== prevStyle.stroke) {\n      ctx.strokeStyle = style.stroke;\n    }\n\n    if (notCheckCache || style.opacity !== prevStyle.opacity) {\n      ctx.globalAlpha = style.opacity == null ? 1 : style.opacity;\n    }\n\n    if (notCheckCache || style.blend !== prevStyle.blend) {\n      ctx.globalCompositeOperation = style.blend || 'source-over';\n    }\n\n    if (this.hasStroke()) {\n      var lineWidth = style.lineWidth;\n      ctx.lineWidth = lineWidth / (this.strokeNoScale && el && el.getLineScale ? el.getLineScale() : 1);\n    }\n  },\n  hasFill: function () {\n    var fill = this.fill;\n    return fill != null && fill !== 'none';\n  },\n  hasStroke: function () {\n    var stroke = this.stroke;\n    return stroke != null && stroke !== 'none' && this.lineWidth > 0;\n  },\n\n  /**\n   * Extend from other style\n   * @param {zrender/graphic/Style} otherStyle\n   * @param {boolean} overwrite true: overwrirte any way.\n   *                            false: overwrite only when !target.hasOwnProperty\n   *                            others: overwrite when property is not null/undefined.\n   */\n  extendFrom: function (otherStyle, overwrite) {\n    if (otherStyle) {\n      for (var name in otherStyle) {\n        if (otherStyle.hasOwnProperty(name) && (overwrite === true || (overwrite === false ? !this.hasOwnProperty(name) : otherStyle[name] != null))) {\n          this[name] = otherStyle[name];\n        }\n      }\n    }\n  },\n\n  /**\n   * Batch setting style with a given object\n   * @param {Object|string} obj\n   * @param {*} [obj]\n   */\n  set: function (obj, value) {\n    if (typeof obj === 'string') {\n      this[obj] = value;\n    } else {\n      this.extendFrom(obj, true);\n    }\n  },\n\n  /**\n   * Clone\n   * @return {zrender/graphic/Style} [description]\n   */\n  clone: function () {\n    var newStyle = new this.constructor();\n    newStyle.extendFrom(this, true);\n    return newStyle;\n  },\n  getGradient: function (ctx, obj, rect) {\n    var method = obj.type === 'radial' ? createRadialGradient : createLinearGradient;\n    var canvasGradient = method(ctx, obj, rect);\n    var colorStops = obj.colorStops;\n\n    for (var i = 0; i < colorStops.length; i++) {\n      canvasGradient.addColorStop(colorStops[i].offset, colorStops[i].color);\n    }\n\n    return canvasGradient;\n  }\n};\nvar styleProto = Style.prototype;\n\nfor (var i = 0; i < STYLE_COMMON_PROPS.length; i++) {\n  var prop = STYLE_COMMON_PROPS[i];\n\n  if (!(prop[0] in styleProto)) {\n    styleProto[prop[0]] = prop[1];\n  }\n} // Provide for others\n\n\nStyle.getGradient = styleProto.getGradient;\nvar _default = Style;\nmodule.exports = _default;\n\n/***/ }),\n/* 43 */\n/***/ (function(module, exports) {\n\n/**\n * zrender: 生成唯一id\n *\n * @author errorrik (errorrik@gmail.com)\n */\nvar idStart = 0x0907;\n\nfunction _default() {\n  return idStart++;\n}\n\nmodule.exports = _default;\n\n/***/ }),\n/* 44 */\n/***/ (function(module, exports) {\n\n/**\n * Event Mixin\n * @module zrender/mixin/Eventful\n * @author Kener (@Kener-林峰, kener.linfeng@gmail.com)\n *         pissang (https://www.github.com/pissang)\n */\nvar arrySlice = Array.prototype.slice;\n/**\n * Event dispatcher.\n *\n * @alias module:zrender/mixin/Eventful\n * @constructor\n * @param {Object} [eventProcessor] The object eventProcessor is the scope when\n *        `eventProcessor.xxx` called.\n * @param {Function} [eventProcessor.normalizeQuery]\n *        param: {string|Object} Raw query.\n *        return: {string|Object} Normalized query.\n * @param {Function} [eventProcessor.filter] Event will be dispatched only\n *        if it returns `true`.\n *        param: {string} eventType\n *        param: {string|Object} query\n *        return: {boolean}\n * @param {Function} [eventProcessor.afterTrigger] Call after all handlers called.\n *        param: {string} eventType\n */\n\nvar Eventful = function (eventProcessor) {\n  this._$handlers = {};\n  this._$eventProcessor = eventProcessor;\n};\n\nEventful.prototype = {\n  constructor: Eventful,\n\n  /**\n   * The handler can only be triggered once, then removed.\n   *\n   * @param {string} event The event name.\n   * @param {string|Object} [query] Condition used on event filter.\n   * @param {Function} handler The event handler.\n   * @param {Object} context\n   */\n  one: function (event, query, handler, context) {\n    return on(this, event, query, handler, context, true);\n  },\n\n  /**\n   * Bind a handler.\n   *\n   * @param {string} event The event name.\n   * @param {string|Object} [query] Condition used on event filter.\n   * @param {Function} handler The event handler.\n   * @param {Object} [context]\n   */\n  on: function (event, query, handler, context) {\n    return on(this, event, query, handler, context, false);\n  },\n\n  /**\n   * Whether any handler has bound.\n   *\n   * @param  {string}  event\n   * @return {boolean}\n   */\n  isSilent: function (event) {\n    var _h = this._$handlers;\n    return !_h[event] || !_h[event].length;\n  },\n\n  /**\n   * Unbind a event.\n   *\n   * @param {string} event The event name.\n   * @param {Function} [handler] The event handler.\n   */\n  off: function (event, handler) {\n    var _h = this._$handlers;\n\n    if (!event) {\n      this._$handlers = {};\n      return this;\n    }\n\n    if (handler) {\n      if (_h[event]) {\n        var newList = [];\n\n        for (var i = 0, l = _h[event].length; i < l; i++) {\n          if (_h[event][i].h !== handler) {\n            newList.push(_h[event][i]);\n          }\n        }\n\n        _h[event] = newList;\n      }\n\n      if (_h[event] && _h[event].length === 0) {\n        delete _h[event];\n      }\n    } else {\n      delete _h[event];\n    }\n\n    return this;\n  },\n\n  /**\n   * Dispatch a event.\n   *\n   * @param {string} type The event name.\n   */\n  trigger: function (type) {\n    var _h = this._$handlers[type];\n    var eventProcessor = this._$eventProcessor;\n\n    if (_h) {\n      var args = arguments;\n      var argLen = args.length;\n\n      if (argLen > 3) {\n        args = arrySlice.call(args, 1);\n      }\n\n      var len = _h.length;\n\n      for (var i = 0; i < len;) {\n        var hItem = _h[i];\n\n        if (eventProcessor && eventProcessor.filter && hItem.query != null && !eventProcessor.filter(type, hItem.query)) {\n          i++;\n          continue;\n        } // Optimize advise from backbone\n\n\n        switch (argLen) {\n          case 1:\n            hItem.h.call(hItem.ctx);\n            break;\n\n          case 2:\n            hItem.h.call(hItem.ctx, args[1]);\n            break;\n\n          case 3:\n            hItem.h.call(hItem.ctx, args[1], args[2]);\n            break;\n\n          default:\n            // have more than 2 given arguments\n            hItem.h.apply(hItem.ctx, args);\n            break;\n        }\n\n        if (hItem.one) {\n          _h.splice(i, 1);\n\n          len--;\n        } else {\n          i++;\n        }\n      }\n    }\n\n    eventProcessor && eventProcessor.afterTrigger && eventProcessor.afterTrigger(type);\n    return this;\n  },\n\n  /**\n   * Dispatch a event with context, which is specified at the last parameter.\n   *\n   * @param {string} type The event name.\n   */\n  triggerWithContext: function (type) {\n    var _h = this._$handlers[type];\n    var eventProcessor = this._$eventProcessor;\n\n    if (_h) {\n      var args = arguments;\n      var argLen = args.length;\n\n      if (argLen > 4) {\n        args = arrySlice.call(args, 1, args.length - 1);\n      }\n\n      var ctx = args[args.length - 1];\n      var len = _h.length;\n\n      for (var i = 0; i < len;) {\n        var hItem = _h[i];\n\n        if (eventProcessor && eventProcessor.filter && hItem.query != null && !eventProcessor.filter(type, hItem.query)) {\n          i++;\n          continue;\n        } // Optimize advise from backbone\n\n\n        switch (argLen) {\n          case 1:\n            hItem.h.call(ctx);\n            break;\n\n          case 2:\n            hItem.h.call(ctx, args[1]);\n            break;\n\n          case 3:\n            hItem.h.call(ctx, args[1], args[2]);\n            break;\n\n          default:\n            // have more than 2 given arguments\n            hItem.h.apply(ctx, args);\n            break;\n        }\n\n        if (hItem.one) {\n          _h.splice(i, 1);\n\n          len--;\n        } else {\n          i++;\n        }\n      }\n    }\n\n    eventProcessor && eventProcessor.afterTrigger && eventProcessor.afterTrigger(type);\n    return this;\n  }\n};\n\nfunction normalizeQuery(host, query) {\n  var eventProcessor = host._$eventProcessor;\n\n  if (query != null && eventProcessor && eventProcessor.normalizeQuery) {\n    query = eventProcessor.normalizeQuery(query);\n  }\n\n  return query;\n}\n\nfunction on(eventful, event, query, handler, context, isOnce) {\n  var _h = eventful._$handlers;\n\n  if (typeof query === 'function') {\n    context = handler;\n    handler = query;\n    query = null;\n  }\n\n  if (!handler || !event) {\n    return eventful;\n  }\n\n  query = normalizeQuery(eventful, query);\n\n  if (!_h[event]) {\n    _h[event] = [];\n  }\n\n  for (var i = 0; i < _h[event].length; i++) {\n    if (_h[event][i].h === handler) {\n      return eventful;\n    }\n  }\n\n  var wrap = {\n    h: handler,\n    one: isOnce,\n    query: query,\n    ctx: context || eventful,\n    // FIXME\n    // Do not publish this feature util it is proved that it makes sense.\n    callAtLast: handler.zrEventfulCallAtLast\n  };\n  var lastIndex = _h[event].length - 1;\n  var lastWrap = _h[event][lastIndex];\n  lastWrap && lastWrap.callAtLast ? _h[event].splice(lastIndex, 0, wrap) : _h[event].push(wrap);\n  return eventful;\n} // ----------------------\n// The events in zrender\n// ----------------------\n\n/**\n * @event module:zrender/mixin/Eventful#onclick\n * @type {Function}\n * @default null\n */\n\n/**\n * @event module:zrender/mixin/Eventful#onmouseover\n * @type {Function}\n * @default null\n */\n\n/**\n * @event module:zrender/mixin/Eventful#onmouseout\n * @type {Function}\n * @default null\n */\n\n/**\n * @event module:zrender/mixin/Eventful#onmousemove\n * @type {Function}\n * @default null\n */\n\n/**\n * @event module:zrender/mixin/Eventful#onmousewheel\n * @type {Function}\n * @default null\n */\n\n/**\n * @event module:zrender/mixin/Eventful#onmousedown\n * @type {Function}\n * @default null\n */\n\n/**\n * @event module:zrender/mixin/Eventful#onmouseup\n * @type {Function}\n * @default null\n */\n\n/**\n * @event module:zrender/mixin/Eventful#ondrag\n * @type {Function}\n * @default null\n */\n\n/**\n * @event module:zrender/mixin/Eventful#ondragstart\n * @type {Function}\n * @default null\n */\n\n/**\n * @event module:zrender/mixin/Eventful#ondragend\n * @type {Function}\n * @default null\n */\n\n/**\n * @event module:zrender/mixin/Eventful#ondragenter\n * @type {Function}\n * @default null\n */\n\n/**\n * @event module:zrender/mixin/Eventful#ondragleave\n * @type {Function}\n * @default null\n */\n\n/**\n * @event module:zrender/mixin/Eventful#ondragover\n * @type {Function}\n * @default null\n */\n\n/**\n * @event module:zrender/mixin/Eventful#ondrop\n * @type {Function}\n * @default null\n */\n\n\nvar _default = Eventful;\nmodule.exports = _default;\n\n/***/ }),\n/* 45 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar Animator = __webpack_require__(46);\n\nvar log = __webpack_require__(49);\n\nvar _util = __webpack_require__(0);\n\nvar isString = _util.isString;\nvar isFunction = _util.isFunction;\nvar isObject = _util.isObject;\nvar isArrayLike = _util.isArrayLike;\nvar indexOf = _util.indexOf;\n\n/**\n * @alias modue:zrender/mixin/Animatable\n * @constructor\n */\nvar Animatable = function () {\n  /**\n   * @type {Array.<module:zrender/animation/Animator>}\n   * @readOnly\n   */\n  this.animators = [];\n};\n\nAnimatable.prototype = {\n  constructor: Animatable,\n\n  /**\n   * 动画\n   *\n   * @param {string} path The path to fetch value from object, like 'a.b.c'.\n   * @param {boolean} [loop] Whether to loop animation.\n   * @return {module:zrender/animation/Animator}\n   * @example:\n   *     el.animate('style', false)\n   *         .when(1000, {x: 10} )\n   *         .done(function(){ // Animation done })\n   *         .start()\n   */\n  animate: function (path, loop) {\n    var target;\n    var animatingShape = false;\n    var el = this;\n    var zr = this.__zr;\n\n    if (path) {\n      var pathSplitted = path.split('.');\n      var prop = el; // If animating shape\n\n      animatingShape = pathSplitted[0] === 'shape';\n\n      for (var i = 0, l = pathSplitted.length; i < l; i++) {\n        if (!prop) {\n          continue;\n        }\n\n        prop = prop[pathSplitted[i]];\n      }\n\n      if (prop) {\n        target = prop;\n      }\n    } else {\n      target = el;\n    }\n\n    if (!target) {\n      log('Property \"' + path + '\" is not existed in element ' + el.id);\n      return;\n    }\n\n    var animators = el.animators;\n    var animator = new Animator(target, loop);\n    animator.during(function (target) {\n      el.dirty(animatingShape);\n    }).done(function () {\n      // FIXME Animator will not be removed if use `Animator#stop` to stop animation\n      animators.splice(indexOf(animators, animator), 1);\n    });\n    animators.push(animator); // If animate after added to the zrender\n\n    if (zr) {\n      zr.animation.addAnimator(animator);\n    }\n\n    return animator;\n  },\n\n  /**\n   * 停止动画\n   * @param {boolean} forwardToLast If move to last frame before stop\n   */\n  stopAnimation: function (forwardToLast) {\n    var animators = this.animators;\n    var len = animators.length;\n\n    for (var i = 0; i < len; i++) {\n      animators[i].stop(forwardToLast);\n    }\n\n    animators.length = 0;\n    return this;\n  },\n\n  /**\n   * Caution: this method will stop previous animation.\n   * So do not use this method to one element twice before\n   * animation starts, unless you know what you are doing.\n   * @param {Object} target\n   * @param {number} [time=500] Time in ms\n   * @param {string} [easing='linear']\n   * @param {number} [delay=0]\n   * @param {Function} [callback]\n   * @param {Function} [forceAnimate] Prevent stop animation and callback\n   *        immediently when target values are the same as current values.\n   *\n   * @example\n   *  // Animate position\n   *  el.animateTo({\n   *      position: [10, 10]\n   *  }, function () { // done })\n   *\n   *  // Animate shape, style and position in 100ms, delayed 100ms, with cubicOut easing\n   *  el.animateTo({\n   *      shape: {\n   *          width: 500\n   *      },\n   *      style: {\n   *          fill: 'red'\n   *      }\n   *      position: [10, 10]\n   *  }, 100, 100, 'cubicOut', function () { // done })\n   */\n  // TODO Return animation key\n  animateTo: function (target, time, delay, easing, callback, forceAnimate) {\n    animateTo(this, target, time, delay, easing, callback, forceAnimate);\n  },\n\n  /**\n   * Animate from the target state to current state.\n   * The params and the return value are the same as `this.animateTo`.\n   */\n  animateFrom: function (target, time, delay, easing, callback, forceAnimate) {\n    animateTo(this, target, time, delay, easing, callback, forceAnimate, true);\n  }\n};\n\nfunction animateTo(animatable, target, time, delay, easing, callback, forceAnimate, reverse) {\n  // animateTo(target, time, easing, callback);\n  if (isString(delay)) {\n    callback = easing;\n    easing = delay;\n    delay = 0;\n  } // animateTo(target, time, delay, callback);\n  else if (isFunction(easing)) {\n      callback = easing;\n      easing = 'linear';\n      delay = 0;\n    } // animateTo(target, time, callback);\n    else if (isFunction(delay)) {\n        callback = delay;\n        delay = 0;\n      } // animateTo(target, callback)\n      else if (isFunction(time)) {\n          callback = time;\n          time = 500;\n        } // animateTo(target)\n        else if (!time) {\n            time = 500;\n          } // Stop all previous animations\n\n\n  animatable.stopAnimation();\n  animateToShallow(animatable, '', animatable, target, time, delay, reverse); // Animators may be removed immediately after start\n  // if there is nothing to animate\n\n  var animators = animatable.animators.slice();\n  var count = animators.length;\n\n  function done() {\n    count--;\n\n    if (!count) {\n      callback && callback();\n    }\n  } // No animators. This should be checked before animators[i].start(),\n  // because 'done' may be executed immediately if no need to animate.\n\n\n  if (!count) {\n    callback && callback();\n  } // Start after all animators created\n  // Incase any animator is done immediately when all animation properties are not changed\n\n\n  for (var i = 0; i < animators.length; i++) {\n    animators[i].done(done).start(easing, forceAnimate);\n  }\n}\n/**\n * @param {string} path=''\n * @param {Object} source=animatable\n * @param {Object} target\n * @param {number} [time=500]\n * @param {number} [delay=0]\n * @param {boolean} [reverse] If `true`, animate\n *        from the `target` to current state.\n *\n * @example\n *  // Animate position\n *  el._animateToShallow({\n *      position: [10, 10]\n *  })\n *\n *  // Animate shape, style and position in 100ms, delayed 100ms\n *  el._animateToShallow({\n *      shape: {\n *          width: 500\n *      },\n *      style: {\n *          fill: 'red'\n *      }\n *      position: [10, 10]\n *  }, 100, 100)\n */\n\n\nfunction animateToShallow(animatable, path, source, target, time, delay, reverse) {\n  var objShallow = {};\n  var propertyCount = 0;\n\n  for (var name in target) {\n    if (!target.hasOwnProperty(name)) {\n      continue;\n    }\n\n    if (source[name] != null) {\n      if (isObject(target[name]) && !isArrayLike(target[name])) {\n        animateToShallow(animatable, path ? path + '.' + name : name, source[name], target[name], time, delay, reverse);\n      } else {\n        if (reverse) {\n          objShallow[name] = source[name];\n          setAttrByPath(animatable, path, name, target[name]);\n        } else {\n          objShallow[name] = target[name];\n        }\n\n        propertyCount++;\n      }\n    } else if (target[name] != null && !reverse) {\n      setAttrByPath(animatable, path, name, target[name]);\n    }\n  }\n\n  if (propertyCount > 0) {\n    animatable.animate(path, false).when(time == null ? 500 : time, objShallow).delay(delay || 0);\n  }\n}\n\nfunction setAttrByPath(el, path, name, value) {\n  // Attr directly if not has property\n  // FIXME, if some property not needed for element ?\n  if (!path) {\n    el.attr(name, value);\n  } else {\n    // Only support set shape or style\n    var props = {};\n    props[path] = {};\n    props[path][name] = value;\n    el.attr(props);\n  }\n}\n\nvar _default = Animatable;\nmodule.exports = _default;\n\n/***/ }),\n/* 46 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar Clip = __webpack_require__(47);\n\nvar color = __webpack_require__(19);\n\nvar _util = __webpack_require__(0);\n\nvar isArrayLike = _util.isArrayLike;\n\n/**\n * @module echarts/animation/Animator\n */\nvar arraySlice = Array.prototype.slice;\n\nfunction defaultGetter(target, key) {\n  return target[key];\n}\n\nfunction defaultSetter(target, key, value) {\n  target[key] = value;\n}\n/**\n * @param  {number} p0\n * @param  {number} p1\n * @param  {number} percent\n * @return {number}\n */\n\n\nfunction interpolateNumber(p0, p1, percent) {\n  return (p1 - p0) * percent + p0;\n}\n/**\n * @param  {string} p0\n * @param  {string} p1\n * @param  {number} percent\n * @return {string}\n */\n\n\nfunction interpolateString(p0, p1, percent) {\n  return percent > 0.5 ? p1 : p0;\n}\n/**\n * @param  {Array} p0\n * @param  {Array} p1\n * @param  {number} percent\n * @param  {Array} out\n * @param  {number} arrDim\n */\n\n\nfunction interpolateArray(p0, p1, percent, out, arrDim) {\n  var len = p0.length;\n\n  if (arrDim === 1) {\n    for (var i = 0; i < len; i++) {\n      out[i] = interpolateNumber(p0[i], p1[i], percent);\n    }\n  } else {\n    var len2 = len && p0[0].length;\n\n    for (var i = 0; i < len; i++) {\n      for (var j = 0; j < len2; j++) {\n        out[i][j] = interpolateNumber(p0[i][j], p1[i][j], percent);\n      }\n    }\n  }\n} // arr0 is source array, arr1 is target array.\n// Do some preprocess to avoid error happened when interpolating from arr0 to arr1\n\n\nfunction fillArr(arr0, arr1, arrDim) {\n  var arr0Len = arr0.length;\n  var arr1Len = arr1.length;\n\n  if (arr0Len !== arr1Len) {\n    // FIXME Not work for TypedArray\n    var isPreviousLarger = arr0Len > arr1Len;\n\n    if (isPreviousLarger) {\n      // Cut the previous\n      arr0.length = arr1Len;\n    } else {\n      // Fill the previous\n      for (var i = arr0Len; i < arr1Len; i++) {\n        arr0.push(arrDim === 1 ? arr1[i] : arraySlice.call(arr1[i]));\n      }\n    }\n  } // Handling NaN value\n\n\n  var len2 = arr0[0] && arr0[0].length;\n\n  for (var i = 0; i < arr0.length; i++) {\n    if (arrDim === 1) {\n      if (isNaN(arr0[i])) {\n        arr0[i] = arr1[i];\n      }\n    } else {\n      for (var j = 0; j < len2; j++) {\n        if (isNaN(arr0[i][j])) {\n          arr0[i][j] = arr1[i][j];\n        }\n      }\n    }\n  }\n}\n/**\n * @param  {Array} arr0\n * @param  {Array} arr1\n * @param  {number} arrDim\n * @return {boolean}\n */\n\n\nfunction isArraySame(arr0, arr1, arrDim) {\n  if (arr0 === arr1) {\n    return true;\n  }\n\n  var len = arr0.length;\n\n  if (len !== arr1.length) {\n    return false;\n  }\n\n  if (arrDim === 1) {\n    for (var i = 0; i < len; i++) {\n      if (arr0[i] !== arr1[i]) {\n        return false;\n      }\n    }\n  } else {\n    var len2 = arr0[0].length;\n\n    for (var i = 0; i < len; i++) {\n      for (var j = 0; j < len2; j++) {\n        if (arr0[i][j] !== arr1[i][j]) {\n          return false;\n        }\n      }\n    }\n  }\n\n  return true;\n}\n/**\n * Catmull Rom interpolate array\n * @param  {Array} p0\n * @param  {Array} p1\n * @param  {Array} p2\n * @param  {Array} p3\n * @param  {number} t\n * @param  {number} t2\n * @param  {number} t3\n * @param  {Array} out\n * @param  {number} arrDim\n */\n\n\nfunction catmullRomInterpolateArray(p0, p1, p2, p3, t, t2, t3, out, arrDim) {\n  var len = p0.length;\n\n  if (arrDim === 1) {\n    for (var i = 0; i < len; i++) {\n      out[i] = catmullRomInterpolate(p0[i], p1[i], p2[i], p3[i], t, t2, t3);\n    }\n  } else {\n    var len2 = p0[0].length;\n\n    for (var i = 0; i < len; i++) {\n      for (var j = 0; j < len2; j++) {\n        out[i][j] = catmullRomInterpolate(p0[i][j], p1[i][j], p2[i][j], p3[i][j], t, t2, t3);\n      }\n    }\n  }\n}\n/**\n * Catmull Rom interpolate number\n * @param  {number} p0\n * @param  {number} p1\n * @param  {number} p2\n * @param  {number} p3\n * @param  {number} t\n * @param  {number} t2\n * @param  {number} t3\n * @return {number}\n */\n\n\nfunction catmullRomInterpolate(p0, p1, p2, p3, t, t2, t3) {\n  var v0 = (p2 - p0) * 0.5;\n  var v1 = (p3 - p1) * 0.5;\n  return (2 * (p1 - p2) + v0 + v1) * t3 + (-3 * (p1 - p2) - 2 * v0 - v1) * t2 + v0 * t + p1;\n}\n\nfunction cloneValue(value) {\n  if (isArrayLike(value)) {\n    var len = value.length;\n\n    if (isArrayLike(value[0])) {\n      var ret = [];\n\n      for (var i = 0; i < len; i++) {\n        ret.push(arraySlice.call(value[i]));\n      }\n\n      return ret;\n    }\n\n    return arraySlice.call(value);\n  }\n\n  return value;\n}\n\nfunction rgba2String(rgba) {\n  rgba[0] = Math.floor(rgba[0]);\n  rgba[1] = Math.floor(rgba[1]);\n  rgba[2] = Math.floor(rgba[2]);\n  return 'rgba(' + rgba.join(',') + ')';\n}\n\nfunction getArrayDim(keyframes) {\n  var lastValue = keyframes[keyframes.length - 1].value;\n  return isArrayLike(lastValue && lastValue[0]) ? 2 : 1;\n}\n\nfunction createTrackClip(animator, easing, oneTrackDone, keyframes, propName, forceAnimate) {\n  var getter = animator._getter;\n  var setter = animator._setter;\n  var useSpline = easing === 'spline';\n  var trackLen = keyframes.length;\n\n  if (!trackLen) {\n    return;\n  } // Guess data type\n\n\n  var firstVal = keyframes[0].value;\n  var isValueArray = isArrayLike(firstVal);\n  var isValueColor = false;\n  var isValueString = false; // For vertices morphing\n\n  var arrDim = isValueArray ? getArrayDim(keyframes) : 0;\n  var trackMaxTime; // Sort keyframe as ascending\n\n  keyframes.sort(function (a, b) {\n    return a.time - b.time;\n  });\n  trackMaxTime = keyframes[trackLen - 1].time; // Percents of each keyframe\n\n  var kfPercents = []; // Value of each keyframe\n\n  var kfValues = [];\n  var prevValue = keyframes[0].value;\n  var isAllValueEqual = true;\n\n  for (var i = 0; i < trackLen; i++) {\n    kfPercents.push(keyframes[i].time / trackMaxTime); // Assume value is a color when it is a string\n\n    var value = keyframes[i].value; // Check if value is equal, deep check if value is array\n\n    if (!(isValueArray && isArraySame(value, prevValue, arrDim) || !isValueArray && value === prevValue)) {\n      isAllValueEqual = false;\n    }\n\n    prevValue = value; // Try converting a string to a color array\n\n    if (typeof value === 'string') {\n      var colorArray = color.parse(value);\n\n      if (colorArray) {\n        value = colorArray;\n        isValueColor = true;\n      } else {\n        isValueString = true;\n      }\n    }\n\n    kfValues.push(value);\n  }\n\n  if (!forceAnimate && isAllValueEqual) {\n    return;\n  }\n\n  var lastValue = kfValues[trackLen - 1]; // Polyfill array and NaN value\n\n  for (var i = 0; i < trackLen - 1; i++) {\n    if (isValueArray) {\n      fillArr(kfValues[i], lastValue, arrDim);\n    } else {\n      if (isNaN(kfValues[i]) && !isNaN(lastValue) && !isValueString && !isValueColor) {\n        kfValues[i] = lastValue;\n      }\n    }\n  }\n\n  isValueArray && fillArr(getter(animator._target, propName), lastValue, arrDim); // Cache the key of last frame to speed up when\n  // animation playback is sequency\n\n  var lastFrame = 0;\n  var lastFramePercent = 0;\n  var start;\n  var w;\n  var p0;\n  var p1;\n  var p2;\n  var p3;\n\n  if (isValueColor) {\n    var rgba = [0, 0, 0, 0];\n  }\n\n  var onframe = function (target, percent) {\n    // Find the range keyframes\n    // kf1-----kf2---------current--------kf3\n    // find kf2 and kf3 and do interpolation\n    var frame; // In the easing function like elasticOut, percent may less than 0\n\n    if (percent < 0) {\n      frame = 0;\n    } else if (percent < lastFramePercent) {\n      // Start from next key\n      // PENDING start from lastFrame ?\n      start = Math.min(lastFrame + 1, trackLen - 1);\n\n      for (frame = start; frame >= 0; frame--) {\n        if (kfPercents[frame] <= percent) {\n          break;\n        }\n      } // PENDING really need to do this ?\n\n\n      frame = Math.min(frame, trackLen - 2);\n    } else {\n      for (frame = lastFrame; frame < trackLen; frame++) {\n        if (kfPercents[frame] > percent) {\n          break;\n        }\n      }\n\n      frame = Math.min(frame - 1, trackLen - 2);\n    }\n\n    lastFrame = frame;\n    lastFramePercent = percent;\n    var range = kfPercents[frame + 1] - kfPercents[frame];\n\n    if (range === 0) {\n      return;\n    } else {\n      w = (percent - kfPercents[frame]) / range;\n    }\n\n    if (useSpline) {\n      p1 = kfValues[frame];\n      p0 = kfValues[frame === 0 ? frame : frame - 1];\n      p2 = kfValues[frame > trackLen - 2 ? trackLen - 1 : frame + 1];\n      p3 = kfValues[frame > trackLen - 3 ? trackLen - 1 : frame + 2];\n\n      if (isValueArray) {\n        catmullRomInterpolateArray(p0, p1, p2, p3, w, w * w, w * w * w, getter(target, propName), arrDim);\n      } else {\n        var value;\n\n        if (isValueColor) {\n          value = catmullRomInterpolateArray(p0, p1, p2, p3, w, w * w, w * w * w, rgba, 1);\n          value = rgba2String(rgba);\n        } else if (isValueString) {\n          // String is step(0.5)\n          return interpolateString(p1, p2, w);\n        } else {\n          value = catmullRomInterpolate(p0, p1, p2, p3, w, w * w, w * w * w);\n        }\n\n        setter(target, propName, value);\n      }\n    } else {\n      if (isValueArray) {\n        interpolateArray(kfValues[frame], kfValues[frame + 1], w, getter(target, propName), arrDim);\n      } else {\n        var value;\n\n        if (isValueColor) {\n          interpolateArray(kfValues[frame], kfValues[frame + 1], w, rgba, 1);\n          value = rgba2String(rgba);\n        } else if (isValueString) {\n          // String is step(0.5)\n          return interpolateString(kfValues[frame], kfValues[frame + 1], w);\n        } else {\n          value = interpolateNumber(kfValues[frame], kfValues[frame + 1], w);\n        }\n\n        setter(target, propName, value);\n      }\n    }\n  };\n\n  var clip = new Clip({\n    target: animator._target,\n    life: trackMaxTime,\n    loop: animator._loop,\n    delay: animator._delay,\n    onframe: onframe,\n    ondestroy: oneTrackDone\n  });\n\n  if (easing && easing !== 'spline') {\n    clip.easing = easing;\n  }\n\n  return clip;\n}\n/**\n * @alias module:zrender/animation/Animator\n * @constructor\n * @param {Object} target\n * @param {boolean} loop\n * @param {Function} getter\n * @param {Function} setter\n */\n\n\nvar Animator = function (target, loop, getter, setter) {\n  this._tracks = {};\n  this._target = target;\n  this._loop = loop || false;\n  this._getter = getter || defaultGetter;\n  this._setter = setter || defaultSetter;\n  this._clipCount = 0;\n  this._delay = 0;\n  this._doneList = [];\n  this._onframeList = [];\n  this._clipList = [];\n};\n\nAnimator.prototype = {\n  /**\n   * 设置动画关键帧\n   * @param  {number} time 关键帧时间，单位是ms\n   * @param  {Object} props 关键帧的属性值，key-value表示\n   * @return {module:zrender/animation/Animator}\n   */\n  when: function (time\n  /* ms */\n  , props) {\n    var tracks = this._tracks;\n\n    for (var propName in props) {\n      if (!props.hasOwnProperty(propName)) {\n        continue;\n      }\n\n      if (!tracks[propName]) {\n        tracks[propName] = []; // Invalid value\n\n        var value = this._getter(this._target, propName);\n\n        if (value == null) {\n          // zrLog('Invalid property ' + propName);\n          continue;\n        } // If time is 0\n        //  Then props is given initialize value\n        // Else\n        //  Initialize value from current prop value\n\n\n        if (time !== 0) {\n          tracks[propName].push({\n            time: 0,\n            value: cloneValue(value)\n          });\n        }\n      }\n\n      tracks[propName].push({\n        time: time,\n        value: props[propName]\n      });\n    }\n\n    return this;\n  },\n\n  /**\n   * 添加动画每一帧的回调函数\n   * @param  {Function} callback\n   * @return {module:zrender/animation/Animator}\n   */\n  during: function (callback) {\n    this._onframeList.push(callback);\n\n    return this;\n  },\n  pause: function () {\n    for (var i = 0; i < this._clipList.length; i++) {\n      this._clipList[i].pause();\n    }\n\n    this._paused = true;\n  },\n  resume: function () {\n    for (var i = 0; i < this._clipList.length; i++) {\n      this._clipList[i].resume();\n    }\n\n    this._paused = false;\n  },\n  isPaused: function () {\n    return !!this._paused;\n  },\n  _doneCallback: function () {\n    // Clear all tracks\n    this._tracks = {}; // Clear all clips\n\n    this._clipList.length = 0;\n    var doneList = this._doneList;\n    var len = doneList.length;\n\n    for (var i = 0; i < len; i++) {\n      doneList[i].call(this);\n    }\n  },\n\n  /**\n   * 开始执行动画\n   * @param  {string|Function} [easing]\n   *         动画缓动函数，详见{@link module:zrender/animation/easing}\n   * @param  {boolean} forceAnimate\n   * @return {module:zrender/animation/Animator}\n   */\n  start: function (easing, forceAnimate) {\n    var self = this;\n    var clipCount = 0;\n\n    var oneTrackDone = function () {\n      clipCount--;\n\n      if (!clipCount) {\n        self._doneCallback();\n      }\n    };\n\n    var lastClip;\n\n    for (var propName in this._tracks) {\n      if (!this._tracks.hasOwnProperty(propName)) {\n        continue;\n      }\n\n      var clip = createTrackClip(this, easing, oneTrackDone, this._tracks[propName], propName, forceAnimate);\n\n      if (clip) {\n        this._clipList.push(clip);\n\n        clipCount++; // If start after added to animation\n\n        if (this.animation) {\n          this.animation.addClip(clip);\n        }\n\n        lastClip = clip;\n      }\n    } // Add during callback on the last clip\n\n\n    if (lastClip) {\n      var oldOnFrame = lastClip.onframe;\n\n      lastClip.onframe = function (target, percent) {\n        oldOnFrame(target, percent);\n\n        for (var i = 0; i < self._onframeList.length; i++) {\n          self._onframeList[i](target, percent);\n        }\n      };\n    } // This optimization will help the case that in the upper application\n    // the view may be refreshed frequently, where animation will be\n    // called repeatly but nothing changed.\n\n\n    if (!clipCount) {\n      this._doneCallback();\n    }\n\n    return this;\n  },\n\n  /**\n   * 停止动画\n   * @param {boolean} forwardToLast If move to last frame before stop\n   */\n  stop: function (forwardToLast) {\n    var clipList = this._clipList;\n    var animation = this.animation;\n\n    for (var i = 0; i < clipList.length; i++) {\n      var clip = clipList[i];\n\n      if (forwardToLast) {\n        // Move to last frame before stop\n        clip.onframe(this._target, 1);\n      }\n\n      animation && animation.removeClip(clip);\n    }\n\n    clipList.length = 0;\n  },\n\n  /**\n   * 设置动画延迟开始的时间\n   * @param  {number} time 单位ms\n   * @return {module:zrender/animation/Animator}\n   */\n  delay: function (time) {\n    this._delay = time;\n    return this;\n  },\n\n  /**\n   * 添加动画结束的回调\n   * @param  {Function} cb\n   * @return {module:zrender/animation/Animator}\n   */\n  done: function (cb) {\n    if (cb) {\n      this._doneList.push(cb);\n    }\n\n    return this;\n  },\n\n  /**\n   * @return {Array.<module:zrender/animation/Clip>}\n   */\n  getClips: function () {\n    return this._clipList;\n  }\n};\nvar _default = Animator;\nmodule.exports = _default;\n\n/***/ }),\n/* 47 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar easingFuncs = __webpack_require__(48);\n\n/**\n * 动画主控制器\n * @config target 动画对象，可以是数组，如果是数组的话会批量分发onframe等事件\n * @config life(1000) 动画时长\n * @config delay(0) 动画延迟时间\n * @config loop(true)\n * @config gap(0) 循环的间隔时间\n * @config onframe\n * @config easing(optional)\n * @config ondestroy(optional)\n * @config onrestart(optional)\n *\n * TODO pause\n */\nfunction Clip(options) {\n  this._target = options.target; // 生命周期\n\n  this._life = options.life || 1000; // 延时\n\n  this._delay = options.delay || 0; // 开始时间\n  // this._startTime = new Date().getTime() + this._delay;// 单位毫秒\n\n  this._initialized = false; // 是否循环\n\n  this.loop = options.loop == null ? false : options.loop;\n  this.gap = options.gap || 0;\n  this.easing = options.easing || 'Linear';\n  this.onframe = options.onframe;\n  this.ondestroy = options.ondestroy;\n  this.onrestart = options.onrestart;\n  this._pausedTime = 0;\n  this._paused = false;\n}\n\nClip.prototype = {\n  constructor: Clip,\n  step: function (globalTime, deltaTime) {\n    // Set startTime on first step, or _startTime may has milleseconds different between clips\n    // PENDING\n    if (!this._initialized) {\n      this._startTime = globalTime + this._delay;\n      this._initialized = true;\n    }\n\n    if (this._paused) {\n      this._pausedTime += deltaTime;\n      return;\n    }\n\n    var percent = (globalTime - this._startTime - this._pausedTime) / this._life; // 还没开始\n\n    if (percent < 0) {\n      return;\n    }\n\n    percent = Math.min(percent, 1);\n    var easing = this.easing;\n    var easingFunc = typeof easing === 'string' ? easingFuncs[easing] : easing;\n    var schedule = typeof easingFunc === 'function' ? easingFunc(percent) : percent;\n    this.fire('frame', schedule); // 结束\n\n    if (percent === 1) {\n      if (this.loop) {\n        this.restart(globalTime); // 重新开始周期\n        // 抛出而不是直接调用事件直到 stage.update 后再统一调用这些事件\n\n        return 'restart';\n      } // 动画完成将这个控制器标识为待删除\n      // 在Animation.update中进行批量删除\n\n\n      this._needsRemove = true;\n      return 'destroy';\n    }\n\n    return null;\n  },\n  restart: function (globalTime) {\n    var remainder = (globalTime - this._startTime - this._pausedTime) % this._life;\n    this._startTime = globalTime - remainder + this.gap;\n    this._pausedTime = 0;\n    this._needsRemove = false;\n  },\n  fire: function (eventType, arg) {\n    eventType = 'on' + eventType;\n\n    if (this[eventType]) {\n      this[eventType](this._target, arg);\n    }\n  },\n  pause: function () {\n    this._paused = true;\n  },\n  resume: function () {\n    this._paused = false;\n  }\n};\nvar _default = Clip;\nmodule.exports = _default;\n\n/***/ }),\n/* 48 */\n/***/ (function(module, exports) {\n\n/**\n * 缓动代码来自 https://github.com/sole/tween.js/blob/master/src/Tween.js\n * @see http://sole.github.io/tween.js/examples/03_graphs.html\n * @exports zrender/animation/easing\n */\nvar easing = {\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  linear: function (k) {\n    return k;\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  quadraticIn: function (k) {\n    return k * k;\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  quadraticOut: function (k) {\n    return k * (2 - k);\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  quadraticInOut: function (k) {\n    if ((k *= 2) < 1) {\n      return 0.5 * k * k;\n    }\n\n    return -0.5 * (--k * (k - 2) - 1);\n  },\n  // 三次方的缓动（t^3）\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  cubicIn: function (k) {\n    return k * k * k;\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  cubicOut: function (k) {\n    return --k * k * k + 1;\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  cubicInOut: function (k) {\n    if ((k *= 2) < 1) {\n      return 0.5 * k * k * k;\n    }\n\n    return 0.5 * ((k -= 2) * k * k + 2);\n  },\n  // 四次方的缓动（t^4）\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  quarticIn: function (k) {\n    return k * k * k * k;\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  quarticOut: function (k) {\n    return 1 - --k * k * k * k;\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  quarticInOut: function (k) {\n    if ((k *= 2) < 1) {\n      return 0.5 * k * k * k * k;\n    }\n\n    return -0.5 * ((k -= 2) * k * k * k - 2);\n  },\n  // 五次方的缓动（t^5）\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  quinticIn: function (k) {\n    return k * k * k * k * k;\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  quinticOut: function (k) {\n    return --k * k * k * k * k + 1;\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  quinticInOut: function (k) {\n    if ((k *= 2) < 1) {\n      return 0.5 * k * k * k * k * k;\n    }\n\n    return 0.5 * ((k -= 2) * k * k * k * k + 2);\n  },\n  // 正弦曲线的缓动（sin(t)）\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  sinusoidalIn: function (k) {\n    return 1 - Math.cos(k * Math.PI / 2);\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  sinusoidalOut: function (k) {\n    return Math.sin(k * Math.PI / 2);\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  sinusoidalInOut: function (k) {\n    return 0.5 * (1 - Math.cos(Math.PI * k));\n  },\n  // 指数曲线的缓动（2^t）\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  exponentialIn: function (k) {\n    return k === 0 ? 0 : Math.pow(1024, k - 1);\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  exponentialOut: function (k) {\n    return k === 1 ? 1 : 1 - Math.pow(2, -10 * k);\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  exponentialInOut: function (k) {\n    if (k === 0) {\n      return 0;\n    }\n\n    if (k === 1) {\n      return 1;\n    }\n\n    if ((k *= 2) < 1) {\n      return 0.5 * Math.pow(1024, k - 1);\n    }\n\n    return 0.5 * (-Math.pow(2, -10 * (k - 1)) + 2);\n  },\n  // 圆形曲线的缓动（sqrt(1-t^2)）\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  circularIn: function (k) {\n    return 1 - Math.sqrt(1 - k * k);\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  circularOut: function (k) {\n    return Math.sqrt(1 - --k * k);\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  circularInOut: function (k) {\n    if ((k *= 2) < 1) {\n      return -0.5 * (Math.sqrt(1 - k * k) - 1);\n    }\n\n    return 0.5 * (Math.sqrt(1 - (k -= 2) * k) + 1);\n  },\n  // 创建类似于弹簧在停止前来回振荡的动画\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  elasticIn: function (k) {\n    var s;\n    var a = 0.1;\n    var p = 0.4;\n\n    if (k === 0) {\n      return 0;\n    }\n\n    if (k === 1) {\n      return 1;\n    }\n\n    if (!a || a < 1) {\n      a = 1;\n      s = p / 4;\n    } else {\n      s = p * Math.asin(1 / a) / (2 * Math.PI);\n    }\n\n    return -(a * Math.pow(2, 10 * (k -= 1)) * Math.sin((k - s) * (2 * Math.PI) / p));\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  elasticOut: function (k) {\n    var s;\n    var a = 0.1;\n    var p = 0.4;\n\n    if (k === 0) {\n      return 0;\n    }\n\n    if (k === 1) {\n      return 1;\n    }\n\n    if (!a || a < 1) {\n      a = 1;\n      s = p / 4;\n    } else {\n      s = p * Math.asin(1 / a) / (2 * Math.PI);\n    }\n\n    return a * Math.pow(2, -10 * k) * Math.sin((k - s) * (2 * Math.PI) / p) + 1;\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  elasticInOut: function (k) {\n    var s;\n    var a = 0.1;\n    var p = 0.4;\n\n    if (k === 0) {\n      return 0;\n    }\n\n    if (k === 1) {\n      return 1;\n    }\n\n    if (!a || a < 1) {\n      a = 1;\n      s = p / 4;\n    } else {\n      s = p * Math.asin(1 / a) / (2 * Math.PI);\n    }\n\n    if ((k *= 2) < 1) {\n      return -0.5 * (a * Math.pow(2, 10 * (k -= 1)) * Math.sin((k - s) * (2 * Math.PI) / p));\n    }\n\n    return a * Math.pow(2, -10 * (k -= 1)) * Math.sin((k - s) * (2 * Math.PI) / p) * 0.5 + 1;\n  },\n  // 在某一动画开始沿指示的路径进行动画处理前稍稍收回该动画的移动\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  backIn: function (k) {\n    var s = 1.70158;\n    return k * k * ((s + 1) * k - s);\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  backOut: function (k) {\n    var s = 1.70158;\n    return --k * k * ((s + 1) * k + s) + 1;\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  backInOut: function (k) {\n    var s = 1.70158 * 1.525;\n\n    if ((k *= 2) < 1) {\n      return 0.5 * (k * k * ((s + 1) * k - s));\n    }\n\n    return 0.5 * ((k -= 2) * k * ((s + 1) * k + s) + 2);\n  },\n  // 创建弹跳效果\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  bounceIn: function (k) {\n    return 1 - easing.bounceOut(1 - k);\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  bounceOut: function (k) {\n    if (k < 1 / 2.75) {\n      return 7.5625 * k * k;\n    } else if (k < 2 / 2.75) {\n      return 7.5625 * (k -= 1.5 / 2.75) * k + 0.75;\n    } else if (k < 2.5 / 2.75) {\n      return 7.5625 * (k -= 2.25 / 2.75) * k + 0.9375;\n    } else {\n      return 7.5625 * (k -= 2.625 / 2.75) * k + 0.984375;\n    }\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  bounceInOut: function (k) {\n    if (k < 0.5) {\n      return easing.bounceIn(k * 2) * 0.5;\n    }\n\n    return easing.bounceOut(k * 2 - 1) * 0.5 + 0.5;\n  }\n};\nvar _default = easing;\nmodule.exports = _default;\n\n/***/ }),\n/* 49 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar _config = __webpack_require__(21);\n\nvar debugMode = _config.debugMode;\n\nvar log = function () {};\n\nif (debugMode === 1) {\n  log = function () {\n    for (var k in arguments) {\n      throw new Error(arguments[k]);\n    }\n  };\n} else if (debugMode > 1) {\n  log = function () {\n    for (var k in arguments) {\n      console.log(arguments[k]);\n    }\n  };\n}\n\nvar _default = log;\nmodule.exports = _default;\n\n/***/ }),\n/* 50 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar textHelper = __webpack_require__(22);\n\nvar BoundingRect = __webpack_require__(3);\n\nvar _constant = __webpack_require__(8);\n\nvar WILL_BE_RESTORED = _constant.WILL_BE_RESTORED;\n\n/**\n * Mixin for drawing text in a element bounding rect\n * @module zrender/mixin/RectText\n */\nvar tmpRect = new BoundingRect();\n\nvar RectText = function () {};\n\nRectText.prototype = {\n  constructor: RectText,\n\n  /**\n   * Draw text in a rect with specified position.\n   * @param  {CanvasRenderingContext2D} ctx\n   * @param  {Object} rect Displayable rect\n   */\n  drawRectText: function (ctx, rect) {\n    var style = this.style;\n    rect = style.textRect || rect; // Optimize, avoid normalize every time.\n\n    this.__dirty && textHelper.normalizeTextStyle(style, true);\n    var text = style.text; // Convert to string\n\n    text != null && (text += '');\n\n    if (!textHelper.needDrawText(text, style)) {\n      return;\n    } // FIXME\n    // Do not provide prevEl to `textHelper.renderText` for ctx prop cache,\n    // but use `ctx.save()` and `ctx.restore()`. Because the cache for rect\n    // text propably break the cache for its host elements.\n\n\n    ctx.save(); // Transform rect to view space\n\n    var transform = this.transform;\n\n    if (!style.transformText) {\n      if (transform) {\n        tmpRect.copy(rect);\n        tmpRect.applyTransform(transform);\n        rect = tmpRect;\n      }\n    } else {\n      this.setTransform(ctx);\n    } // transformText and textRotation can not be used at the same time.\n\n\n    textHelper.renderText(this, ctx, text, style, rect, WILL_BE_RESTORED);\n    ctx.restore();\n  }\n};\nvar _default = RectText;\nmodule.exports = _default;\n\n/***/ }),\n/* 51 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar vec2 = __webpack_require__(2);\n\nvar curve = __webpack_require__(4);\n\n/**\n * @author Yi Shen(https://github.com/pissang)\n */\nvar mathMin = Math.min;\nvar mathMax = Math.max;\nvar mathSin = Math.sin;\nvar mathCos = Math.cos;\nvar PI2 = Math.PI * 2;\nvar start = vec2.create();\nvar end = vec2.create();\nvar extremity = vec2.create();\n/**\n * 从顶点数组中计算出最小包围盒，写入`min`和`max`中\n * @module zrender/core/bbox\n * @param {Array<Object>} points 顶点数组\n * @param {number} min\n * @param {number} max\n */\n\nfunction fromPoints(points, min, max) {\n  if (points.length === 0) {\n    return;\n  }\n\n  var p = points[0];\n  var left = p[0];\n  var right = p[0];\n  var top = p[1];\n  var bottom = p[1];\n  var i;\n\n  for (i = 1; i < points.length; i++) {\n    p = points[i];\n    left = mathMin(left, p[0]);\n    right = mathMax(right, p[0]);\n    top = mathMin(top, p[1]);\n    bottom = mathMax(bottom, p[1]);\n  }\n\n  min[0] = left;\n  min[1] = top;\n  max[0] = right;\n  max[1] = bottom;\n}\n/**\n * @memberOf module:zrender/core/bbox\n * @param {number} x0\n * @param {number} y0\n * @param {number} x1\n * @param {number} y1\n * @param {Array.<number>} min\n * @param {Array.<number>} max\n */\n\n\nfunction fromLine(x0, y0, x1, y1, min, max) {\n  min[0] = mathMin(x0, x1);\n  min[1] = mathMin(y0, y1);\n  max[0] = mathMax(x0, x1);\n  max[1] = mathMax(y0, y1);\n}\n\nvar xDim = [];\nvar yDim = [];\n/**\n * 从三阶贝塞尔曲线(p0, p1, p2, p3)中计算出最小包围盒，写入`min`和`max`中\n * @memberOf module:zrender/core/bbox\n * @param {number} x0\n * @param {number} y0\n * @param {number} x1\n * @param {number} y1\n * @param {number} x2\n * @param {number} y2\n * @param {number} x3\n * @param {number} y3\n * @param {Array.<number>} min\n * @param {Array.<number>} max\n */\n\nfunction fromCubic(x0, y0, x1, y1, x2, y2, x3, y3, min, max) {\n  var cubicExtrema = curve.cubicExtrema;\n  var cubicAt = curve.cubicAt;\n  var i;\n  var n = cubicExtrema(x0, x1, x2, x3, xDim);\n  min[0] = Infinity;\n  min[1] = Infinity;\n  max[0] = -Infinity;\n  max[1] = -Infinity;\n\n  for (i = 0; i < n; i++) {\n    var x = cubicAt(x0, x1, x2, x3, xDim[i]);\n    min[0] = mathMin(x, min[0]);\n    max[0] = mathMax(x, max[0]);\n  }\n\n  n = cubicExtrema(y0, y1, y2, y3, yDim);\n\n  for (i = 0; i < n; i++) {\n    var y = cubicAt(y0, y1, y2, y3, yDim[i]);\n    min[1] = mathMin(y, min[1]);\n    max[1] = mathMax(y, max[1]);\n  }\n\n  min[0] = mathMin(x0, min[0]);\n  max[0] = mathMax(x0, max[0]);\n  min[0] = mathMin(x3, min[0]);\n  max[0] = mathMax(x3, max[0]);\n  min[1] = mathMin(y0, min[1]);\n  max[1] = mathMax(y0, max[1]);\n  min[1] = mathMin(y3, min[1]);\n  max[1] = mathMax(y3, max[1]);\n}\n/**\n * 从二阶贝塞尔曲线(p0, p1, p2)中计算出最小包围盒，写入`min`和`max`中\n * @memberOf module:zrender/core/bbox\n * @param {number} x0\n * @param {number} y0\n * @param {number} x1\n * @param {number} y1\n * @param {number} x2\n * @param {number} y2\n * @param {Array.<number>} min\n * @param {Array.<number>} max\n */\n\n\nfunction fromQuadratic(x0, y0, x1, y1, x2, y2, min, max) {\n  var quadraticExtremum = curve.quadraticExtremum;\n  var quadraticAt = curve.quadraticAt; // Find extremities, where derivative in x dim or y dim is zero\n\n  var tx = mathMax(mathMin(quadraticExtremum(x0, x1, x2), 1), 0);\n  var ty = mathMax(mathMin(quadraticExtremum(y0, y1, y2), 1), 0);\n  var x = quadraticAt(x0, x1, x2, tx);\n  var y = quadraticAt(y0, y1, y2, ty);\n  min[0] = mathMin(x0, x2, x);\n  min[1] = mathMin(y0, y2, y);\n  max[0] = mathMax(x0, x2, x);\n  max[1] = mathMax(y0, y2, y);\n}\n/**\n * 从圆弧中计算出最小包围盒，写入`min`和`max`中\n * @method\n * @memberOf module:zrender/core/bbox\n * @param {number} x\n * @param {number} y\n * @param {number} rx\n * @param {number} ry\n * @param {number} startAngle\n * @param {number} endAngle\n * @param {number} anticlockwise\n * @param {Array.<number>} min\n * @param {Array.<number>} max\n */\n\n\nfunction fromArc(x, y, rx, ry, startAngle, endAngle, anticlockwise, min, max) {\n  var vec2Min = vec2.min;\n  var vec2Max = vec2.max;\n  var diff = Math.abs(startAngle - endAngle);\n\n  if (diff % PI2 < 1e-4 && diff > 1e-4) {\n    // Is a circle\n    min[0] = x - rx;\n    min[1] = y - ry;\n    max[0] = x + rx;\n    max[1] = y + ry;\n    return;\n  }\n\n  start[0] = mathCos(startAngle) * rx + x;\n  start[1] = mathSin(startAngle) * ry + y;\n  end[0] = mathCos(endAngle) * rx + x;\n  end[1] = mathSin(endAngle) * ry + y;\n  vec2Min(min, start, end);\n  vec2Max(max, start, end); // Thresh to [0, Math.PI * 2]\n\n  startAngle = startAngle % PI2;\n\n  if (startAngle < 0) {\n    startAngle = startAngle + PI2;\n  }\n\n  endAngle = endAngle % PI2;\n\n  if (endAngle < 0) {\n    endAngle = endAngle + PI2;\n  }\n\n  if (startAngle > endAngle && !anticlockwise) {\n    endAngle += PI2;\n  } else if (startAngle < endAngle && anticlockwise) {\n    startAngle += PI2;\n  }\n\n  if (anticlockwise) {\n    var tmp = endAngle;\n    endAngle = startAngle;\n    startAngle = tmp;\n  } // var number = 0;\n  // var step = (anticlockwise ? -Math.PI : Math.PI) / 2;\n\n\n  for (var angle = 0; angle < endAngle; angle += Math.PI / 2) {\n    if (angle > startAngle) {\n      extremity[0] = mathCos(angle) * rx + x;\n      extremity[1] = mathSin(angle) * ry + y;\n      vec2Min(min, extremity, min);\n      vec2Max(max, extremity, max);\n    }\n  }\n}\n\nexports.fromPoints = fromPoints;\nexports.fromLine = fromLine;\nexports.fromCubic = fromCubic;\nexports.fromQuadratic = fromQuadratic;\nexports.fromArc = fromArc;\n\n/***/ }),\n/* 52 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar PathProxy = __webpack_require__(9);\n\nvar line = __webpack_require__(53);\n\nvar cubic = __webpack_require__(54);\n\nvar quadratic = __webpack_require__(55);\n\nvar arc = __webpack_require__(56);\n\nvar _util = __webpack_require__(25);\n\nvar normalizeRadian = _util.normalizeRadian;\n\nvar curve = __webpack_require__(4);\n\nvar windingLine = __webpack_require__(57);\n\nvar CMD = PathProxy.CMD;\nvar PI2 = Math.PI * 2;\nvar EPSILON = 1e-4;\n\nfunction isAroundEqual(a, b) {\n  return Math.abs(a - b) < EPSILON;\n} // 临时数组\n\n\nvar roots = [-1, -1, -1];\nvar extrema = [-1, -1];\n\nfunction swapExtrema() {\n  var tmp = extrema[0];\n  extrema[0] = extrema[1];\n  extrema[1] = tmp;\n}\n\nfunction windingCubic(x0, y0, x1, y1, x2, y2, x3, y3, x, y) {\n  // Quick reject\n  if (y > y0 && y > y1 && y > y2 && y > y3 || y < y0 && y < y1 && y < y2 && y < y3) {\n    return 0;\n  }\n\n  var nRoots = curve.cubicRootAt(y0, y1, y2, y3, y, roots);\n\n  if (nRoots === 0) {\n    return 0;\n  } else {\n    var w = 0;\n    var nExtrema = -1;\n    var y0_;\n    var y1_;\n\n    for (var i = 0; i < nRoots; i++) {\n      var t = roots[i]; // Avoid winding error when intersection point is the connect point of two line of polygon\n\n      var unit = t === 0 || t === 1 ? 0.5 : 1;\n      var x_ = curve.cubicAt(x0, x1, x2, x3, t);\n\n      if (x_ < x) {\n        // Quick reject\n        continue;\n      }\n\n      if (nExtrema < 0) {\n        nExtrema = curve.cubicExtrema(y0, y1, y2, y3, extrema);\n\n        if (extrema[1] < extrema[0] && nExtrema > 1) {\n          swapExtrema();\n        }\n\n        y0_ = curve.cubicAt(y0, y1, y2, y3, extrema[0]);\n\n        if (nExtrema > 1) {\n          y1_ = curve.cubicAt(y0, y1, y2, y3, extrema[1]);\n        }\n      }\n\n      if (nExtrema === 2) {\n        // 分成三段单调函数\n        if (t < extrema[0]) {\n          w += y0_ < y0 ? unit : -unit;\n        } else if (t < extrema[1]) {\n          w += y1_ < y0_ ? unit : -unit;\n        } else {\n          w += y3 < y1_ ? unit : -unit;\n        }\n      } else {\n        // 分成两段单调函数\n        if (t < extrema[0]) {\n          w += y0_ < y0 ? unit : -unit;\n        } else {\n          w += y3 < y0_ ? unit : -unit;\n        }\n      }\n    }\n\n    return w;\n  }\n}\n\nfunction windingQuadratic(x0, y0, x1, y1, x2, y2, x, y) {\n  // Quick reject\n  if (y > y0 && y > y1 && y > y2 || y < y0 && y < y1 && y < y2) {\n    return 0;\n  }\n\n  var nRoots = curve.quadraticRootAt(y0, y1, y2, y, roots);\n\n  if (nRoots === 0) {\n    return 0;\n  } else {\n    var t = curve.quadraticExtremum(y0, y1, y2);\n\n    if (t >= 0 && t <= 1) {\n      var w = 0;\n      var y_ = curve.quadraticAt(y0, y1, y2, t);\n\n      for (var i = 0; i < nRoots; i++) {\n        // Remove one endpoint.\n        var unit = roots[i] === 0 || roots[i] === 1 ? 0.5 : 1;\n        var x_ = curve.quadraticAt(x0, x1, x2, roots[i]);\n\n        if (x_ < x) {\n          // Quick reject\n          continue;\n        }\n\n        if (roots[i] < t) {\n          w += y_ < y0 ? unit : -unit;\n        } else {\n          w += y2 < y_ ? unit : -unit;\n        }\n      }\n\n      return w;\n    } else {\n      // Remove one endpoint.\n      var unit = roots[0] === 0 || roots[0] === 1 ? 0.5 : 1;\n      var x_ = curve.quadraticAt(x0, x1, x2, roots[0]);\n\n      if (x_ < x) {\n        // Quick reject\n        return 0;\n      }\n\n      return y2 < y0 ? unit : -unit;\n    }\n  }\n} // TODO\n// Arc 旋转\n\n\nfunction windingArc(cx, cy, r, startAngle, endAngle, anticlockwise, x, y) {\n  y -= cy;\n\n  if (y > r || y < -r) {\n    return 0;\n  }\n\n  var tmp = Math.sqrt(r * r - y * y);\n  roots[0] = -tmp;\n  roots[1] = tmp;\n  var diff = Math.abs(startAngle - endAngle);\n\n  if (diff < 1e-4) {\n    return 0;\n  }\n\n  if (diff % PI2 < 1e-4) {\n    // Is a circle\n    startAngle = 0;\n    endAngle = PI2;\n    var dir = anticlockwise ? 1 : -1;\n\n    if (x >= roots[0] + cx && x <= roots[1] + cx) {\n      return dir;\n    } else {\n      return 0;\n    }\n  }\n\n  if (anticlockwise) {\n    var tmp = startAngle;\n    startAngle = normalizeRadian(endAngle);\n    endAngle = normalizeRadian(tmp);\n  } else {\n    startAngle = normalizeRadian(startAngle);\n    endAngle = normalizeRadian(endAngle);\n  }\n\n  if (startAngle > endAngle) {\n    endAngle += PI2;\n  }\n\n  var w = 0;\n\n  for (var i = 0; i < 2; i++) {\n    var x_ = roots[i];\n\n    if (x_ + cx > x) {\n      var angle = Math.atan2(y, x_);\n      var dir = anticlockwise ? 1 : -1;\n\n      if (angle < 0) {\n        angle = PI2 + angle;\n      }\n\n      if (angle >= startAngle && angle <= endAngle || angle + PI2 >= startAngle && angle + PI2 <= endAngle) {\n        if (angle > Math.PI / 2 && angle < Math.PI * 1.5) {\n          dir = -dir;\n        }\n\n        w += dir;\n      }\n    }\n  }\n\n  return w;\n}\n\nfunction containPath(data, lineWidth, isStroke, x, y) {\n  var w = 0;\n  var xi = 0;\n  var yi = 0;\n  var x0 = 0;\n  var y0 = 0;\n\n  for (var i = 0; i < data.length;) {\n    var cmd = data[i++]; // Begin a new subpath\n\n    if (cmd === CMD.M && i > 1) {\n      // Close previous subpath\n      if (!isStroke) {\n        w += windingLine(xi, yi, x0, y0, x, y);\n      } // 如果被任何一个 subpath 包含\n      // if (w !== 0) {\n      //     return true;\n      // }\n\n    }\n\n    if (i === 1) {\n      // 如果第一个命令是 L, C, Q\n      // 则 previous point 同绘制命令的第一个 point\n      //\n      // 第一个命令为 Arc 的情况下会在后面特殊处理\n      xi = data[i];\n      yi = data[i + 1];\n      x0 = xi;\n      y0 = yi;\n    }\n\n    switch (cmd) {\n      case CMD.M:\n        // moveTo 命令重新创建一个新的 subpath, 并且更新新的起点\n        // 在 closePath 的时候使用\n        x0 = data[i++];\n        y0 = data[i++];\n        xi = x0;\n        yi = y0;\n        break;\n\n      case CMD.L:\n        if (isStroke) {\n          if (line.containStroke(xi, yi, data[i], data[i + 1], lineWidth, x, y)) {\n            return true;\n          }\n        } else {\n          // NOTE 在第一个命令为 L, C, Q 的时候会计算出 NaN\n          w += windingLine(xi, yi, data[i], data[i + 1], x, y) || 0;\n        }\n\n        xi = data[i++];\n        yi = data[i++];\n        break;\n\n      case CMD.C:\n        if (isStroke) {\n          if (cubic.containStroke(xi, yi, data[i++], data[i++], data[i++], data[i++], data[i], data[i + 1], lineWidth, x, y)) {\n            return true;\n          }\n        } else {\n          w += windingCubic(xi, yi, data[i++], data[i++], data[i++], data[i++], data[i], data[i + 1], x, y) || 0;\n        }\n\n        xi = data[i++];\n        yi = data[i++];\n        break;\n\n      case CMD.Q:\n        if (isStroke) {\n          if (quadratic.containStroke(xi, yi, data[i++], data[i++], data[i], data[i + 1], lineWidth, x, y)) {\n            return true;\n          }\n        } else {\n          w += windingQuadratic(xi, yi, data[i++], data[i++], data[i], data[i + 1], x, y) || 0;\n        }\n\n        xi = data[i++];\n        yi = data[i++];\n        break;\n\n      case CMD.A:\n        // TODO Arc 判断的开销比较大\n        var cx = data[i++];\n        var cy = data[i++];\n        var rx = data[i++];\n        var ry = data[i++];\n        var theta = data[i++];\n        var dTheta = data[i++]; // TODO Arc 旋转\n\n        i += 1;\n        var anticlockwise = 1 - data[i++];\n        var x1 = Math.cos(theta) * rx + cx;\n        var y1 = Math.sin(theta) * ry + cy; // 不是直接使用 arc 命令\n\n        if (i > 1) {\n          w += windingLine(xi, yi, x1, y1, x, y);\n        } else {\n          // 第一个命令起点还未定义\n          x0 = x1;\n          y0 = y1;\n        } // zr 使用scale来模拟椭圆, 这里也对x做一定的缩放\n\n\n        var _x = (x - cx) * ry / rx + cx;\n\n        if (isStroke) {\n          if (arc.containStroke(cx, cy, ry, theta, theta + dTheta, anticlockwise, lineWidth, _x, y)) {\n            return true;\n          }\n        } else {\n          w += windingArc(cx, cy, ry, theta, theta + dTheta, anticlockwise, _x, y);\n        }\n\n        xi = Math.cos(theta + dTheta) * rx + cx;\n        yi = Math.sin(theta + dTheta) * ry + cy;\n        break;\n\n      case CMD.R:\n        x0 = xi = data[i++];\n        y0 = yi = data[i++];\n        var width = data[i++];\n        var height = data[i++];\n        var x1 = x0 + width;\n        var y1 = y0 + height;\n\n        if (isStroke) {\n          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)) {\n            return true;\n          }\n        } else {\n          // FIXME Clockwise ?\n          w += windingLine(x1, y0, x1, y1, x, y);\n          w += windingLine(x0, y1, x0, y0, x, y);\n        }\n\n        break;\n\n      case CMD.Z:\n        if (isStroke) {\n          if (line.containStroke(xi, yi, x0, y0, lineWidth, x, y)) {\n            return true;\n          }\n        } else {\n          // Close a subpath\n          w += windingLine(xi, yi, x0, y0, x, y); // 如果被任何一个 subpath 包含\n          // FIXME subpaths may overlap\n          // if (w !== 0) {\n          //     return true;\n          // }\n        }\n\n        xi = x0;\n        yi = y0;\n        break;\n    }\n  }\n\n  if (!isStroke && !isAroundEqual(yi, y0)) {\n    w += windingLine(xi, yi, x0, y0, x, y) || 0;\n  }\n\n  return w !== 0;\n}\n\nfunction contain(pathData, x, y) {\n  return containPath(pathData, 0, false, x, y);\n}\n\nfunction containStroke(pathData, lineWidth, x, y) {\n  return containPath(pathData, lineWidth, true, x, y);\n}\n\nexports.contain = contain;\nexports.containStroke = containStroke;\n\n/***/ }),\n/* 53 */\n/***/ (function(module, exports) {\n\n/**\n * 线段包含判断\n * @param  {number}  x0\n * @param  {number}  y0\n * @param  {number}  x1\n * @param  {number}  y1\n * @param  {number}  lineWidth\n * @param  {number}  x\n * @param  {number}  y\n * @return {boolean}\n */\nfunction containStroke(x0, y0, x1, y1, lineWidth, x, y) {\n  if (lineWidth === 0) {\n    return false;\n  }\n\n  var _l = lineWidth;\n  var _a = 0;\n  var _b = x0; // Quick reject\n\n  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) {\n    return false;\n  }\n\n  if (x0 !== x1) {\n    _a = (y0 - y1) / (x0 - x1);\n    _b = (x0 * y1 - x1 * y0) / (x0 - x1);\n  } else {\n    return Math.abs(x - x0) <= _l / 2;\n  }\n\n  var tmp = _a * x - y + _b;\n\n  var _s = tmp * tmp / (_a * _a + 1);\n\n  return _s <= _l / 2 * _l / 2;\n}\n\nexports.containStroke = containStroke;\n\n/***/ }),\n/* 54 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar curve = __webpack_require__(4);\n\n/**\n * 三次贝塞尔曲线描边包含判断\n * @param  {number}  x0\n * @param  {number}  y0\n * @param  {number}  x1\n * @param  {number}  y1\n * @param  {number}  x2\n * @param  {number}  y2\n * @param  {number}  x3\n * @param  {number}  y3\n * @param  {number}  lineWidth\n * @param  {number}  x\n * @param  {number}  y\n * @return {boolean}\n */\nfunction containStroke(x0, y0, x1, y1, x2, y2, x3, y3, lineWidth, x, y) {\n  if (lineWidth === 0) {\n    return false;\n  }\n\n  var _l = lineWidth; // Quick reject\n\n  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) {\n    return false;\n  }\n\n  var d = curve.cubicProjectPoint(x0, y0, x1, y1, x2, y2, x3, y3, x, y, null);\n  return d <= _l / 2;\n}\n\nexports.containStroke = containStroke;\n\n/***/ }),\n/* 55 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar _curve = __webpack_require__(4);\n\nvar quadraticProjectPoint = _curve.quadraticProjectPoint;\n\n/**\n * 二次贝塞尔曲线描边包含判断\n * @param  {number}  x0\n * @param  {number}  y0\n * @param  {number}  x1\n * @param  {number}  y1\n * @param  {number}  x2\n * @param  {number}  y2\n * @param  {number}  lineWidth\n * @param  {number}  x\n * @param  {number}  y\n * @return {boolean}\n */\nfunction containStroke(x0, y0, x1, y1, x2, y2, lineWidth, x, y) {\n  if (lineWidth === 0) {\n    return false;\n  }\n\n  var _l = lineWidth; // Quick reject\n\n  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) {\n    return false;\n  }\n\n  var d = quadraticProjectPoint(x0, y0, x1, y1, x2, y2, x, y, null);\n  return d <= _l / 2;\n}\n\nexports.containStroke = containStroke;\n\n/***/ }),\n/* 56 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar _util = __webpack_require__(25);\n\nvar normalizeRadian = _util.normalizeRadian;\nvar PI2 = Math.PI * 2;\n/**\n * 圆弧描边包含判断\n * @param  {number}  cx\n * @param  {number}  cy\n * @param  {number}  r\n * @param  {number}  startAngle\n * @param  {number}  endAngle\n * @param  {boolean}  anticlockwise\n * @param  {number} lineWidth\n * @param  {number}  x\n * @param  {number}  y\n * @return {Boolean}\n */\n\nfunction containStroke(cx, cy, r, startAngle, endAngle, anticlockwise, lineWidth, x, y) {\n  if (lineWidth === 0) {\n    return false;\n  }\n\n  var _l = lineWidth;\n  x -= cx;\n  y -= cy;\n  var d = Math.sqrt(x * x + y * y);\n\n  if (d - _l > r || d + _l < r) {\n    return false;\n  }\n\n  if (Math.abs(startAngle - endAngle) % PI2 < 1e-4) {\n    // Is a circle\n    return true;\n  }\n\n  if (anticlockwise) {\n    var tmp = startAngle;\n    startAngle = normalizeRadian(endAngle);\n    endAngle = normalizeRadian(tmp);\n  } else {\n    startAngle = normalizeRadian(startAngle);\n    endAngle = normalizeRadian(endAngle);\n  }\n\n  if (startAngle > endAngle) {\n    endAngle += PI2;\n  }\n\n  var angle = Math.atan2(y, x);\n\n  if (angle < 0) {\n    angle += PI2;\n  }\n\n  return angle >= startAngle && angle <= endAngle || angle + PI2 >= startAngle && angle + PI2 <= endAngle;\n}\n\nexports.containStroke = containStroke;\n\n/***/ }),\n/* 57 */\n/***/ (function(module, exports) {\n\nfunction windingLine(x0, y0, x1, y1, x, y) {\n  if (y > y0 && y > y1 || y < y0 && y < y1) {\n    return 0;\n  } // Ignore horizontal line\n\n\n  if (y1 === y0) {\n    return 0;\n  }\n\n  var dir = y1 < y0 ? 1 : -1;\n  var t = (y - y0) / (y1 - y0); // Avoid winding error when intersection point is the connect point of two line of polygon\n\n  if (t === 1 || t === 0) {\n    dir = y1 < y0 ? 0.5 : -0.5;\n  }\n\n  var x_ = t * (x1 - x0) + x0; // If (x, y) on the line, considered as \"contain\".\n\n  return x_ === x ? Infinity : x_ > x ? dir : 0;\n}\n\nmodule.exports = windingLine;\n\n/***/ }),\n/* 58 */\n/***/ (function(module, exports) {\n\nvar Pattern = function (image, repeat) {\n  // Should do nothing more in this constructor. Because gradient can be\n  // declard by `color: {image: ...}`, where this constructor will not be called.\n  this.image = image;\n  this.repeat = repeat; // Can be cloned\n\n  this.type = 'pattern';\n};\n\nPattern.prototype.getCanvasPattern = function (ctx) {\n  return ctx.createPattern(this.image, this.repeat || 'repeat');\n};\n\nvar _default = Pattern;\nmodule.exports = _default;\n\n/***/ }),\n/* 59 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar PathProxy = __webpack_require__(9);\n\nvar _vector = __webpack_require__(2);\n\nvar v2ApplyTransform = _vector.applyTransform;\nvar CMD = PathProxy.CMD;\nvar points = [[], [], []];\nvar mathSqrt = Math.sqrt;\nvar mathAtan2 = Math.atan2;\n\nfunction _default(path, m) {\n  var data = path.data;\n  var cmd;\n  var nPoint;\n  var i;\n  var j;\n  var k;\n  var p;\n  var M = CMD.M;\n  var C = CMD.C;\n  var L = CMD.L;\n  var R = CMD.R;\n  var A = CMD.A;\n  var Q = CMD.Q;\n\n  for (i = 0, j = 0; i < data.length;) {\n    cmd = data[i++];\n    j = i;\n    nPoint = 0;\n\n    switch (cmd) {\n      case M:\n        nPoint = 1;\n        break;\n\n      case L:\n        nPoint = 1;\n        break;\n\n      case C:\n        nPoint = 3;\n        break;\n\n      case Q:\n        nPoint = 2;\n        break;\n\n      case A:\n        var x = m[4];\n        var y = m[5];\n        var sx = mathSqrt(m[0] * m[0] + m[1] * m[1]);\n        var sy = mathSqrt(m[2] * m[2] + m[3] * m[3]);\n        var angle = mathAtan2(-m[1] / sy, m[0] / sx); // cx\n\n        data[i] *= sx;\n        data[i++] += x; // cy\n\n        data[i] *= sy;\n        data[i++] += y; // Scale rx and ry\n        // FIXME Assume psi is 0 here\n\n        data[i++] *= sx;\n        data[i++] *= sy; // Start angle\n\n        data[i++] += angle; // end angle\n\n        data[i++] += angle; // FIXME psi\n\n        i += 2;\n        j = i;\n        break;\n\n      case R:\n        // x0, y0\n        p[0] = data[i++];\n        p[1] = data[i++];\n        v2ApplyTransform(p, p, m);\n        data[j++] = p[0];\n        data[j++] = p[1]; // x1, y1\n\n        p[0] += data[i++];\n        p[1] += data[i++];\n        v2ApplyTransform(p, p, m);\n        data[j++] = p[0];\n        data[j++] = p[1];\n    }\n\n    for (k = 0; k < nPoint; k++) {\n      var p = points[k];\n      p[0] = data[i++];\n      p[1] = data[i++];\n      v2ApplyTransform(p, p, m); // Write back\n\n      data[j++] = p[0];\n      data[j++] = p[1];\n    }\n  }\n}\n\nmodule.exports = _default;\n\n/***/ }),\n/* 60 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar Displayable = __webpack_require__(7);\n\nvar BoundingRect = __webpack_require__(3);\n\nvar zrUtil = __webpack_require__(0);\n\nvar imageHelper = __webpack_require__(11);\n\n/**\n * @alias zrender/graphic/Image\n * @extends module:zrender/graphic/Displayable\n * @constructor\n * @param {Object} opts\n */\nfunction ZImage(opts) {\n  Displayable.call(this, opts);\n}\n\nZImage.prototype = {\n  constructor: ZImage,\n  type: 'image',\n  brush: function (ctx, prevEl) {\n    var style = this.style;\n    var src = style.image; // Must bind each time\n\n    style.bind(ctx, this, prevEl);\n    var image = this._image = imageHelper.createOrUpdateImage(src, this._image, this, this.onload);\n\n    if (!image || !imageHelper.isImageReady(image)) {\n      return;\n    } // 图片已经加载完成\n    // if (image.nodeName.toUpperCase() == 'IMG') {\n    //     if (!image.complete) {\n    //         return;\n    //     }\n    // }\n    // Else is canvas\n\n\n    var x = style.x || 0;\n    var y = style.y || 0;\n    var width = style.width;\n    var height = style.height;\n    var aspect = image.width / image.height;\n\n    if (width == null && height != null) {\n      // Keep image/height ratio\n      width = height * aspect;\n    } else if (height == null && width != null) {\n      height = width / aspect;\n    } else if (width == null && height == null) {\n      width = image.width;\n      height = image.height;\n    } // 设置transform\n\n\n    this.setTransform(ctx);\n\n    if (style.sWidth && style.sHeight) {\n      var sx = style.sx || 0;\n      var sy = style.sy || 0;\n      ctx.drawImage(image, sx, sy, style.sWidth, style.sHeight, x, y, width, height);\n    } else if (style.sx && style.sy) {\n      var sx = style.sx;\n      var sy = style.sy;\n      var sWidth = width - sx;\n      var sHeight = height - sy;\n      ctx.drawImage(image, sx, sy, sWidth, sHeight, x, y, width, height);\n    } else {\n      ctx.drawImage(image, x, y, width, height);\n    } // Draw rect text\n\n\n    if (style.text != null) {\n      // Only restore transform when needs draw text.\n      this.restoreTransform(ctx);\n      this.drawRectText(ctx, this.getBoundingRect());\n    }\n  },\n  getBoundingRect: function () {\n    var style = this.style;\n\n    if (!this._rect) {\n      this._rect = new BoundingRect(style.x || 0, style.y || 0, style.width || 0, style.height || 0);\n    }\n\n    return this._rect;\n  }\n};\nzrUtil.inherits(ZImage, Displayable);\nvar _default = ZImage;\nmodule.exports = _default;\n\n/***/ }),\n/* 61 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar zrUtil = __webpack_require__(0);\n\nvar Element = __webpack_require__(17);\n\nvar BoundingRect = __webpack_require__(3);\n\n/**\n * Group是一个容器，可以插入子节点，Group的变换也会被应用到子节点上\n * @module zrender/graphic/Group\n * @example\n *     var Group = require('zrender/container/Group');\n *     var Circle = require('zrender/graphic/shape/Circle');\n *     var g = new Group();\n *     g.position[0] = 100;\n *     g.position[1] = 100;\n *     g.add(new Circle({\n *         style: {\n *             x: 100,\n *             y: 100,\n *             r: 20,\n *         }\n *     }));\n *     zr.add(g);\n */\n\n/**\n * @alias module:zrender/graphic/Group\n * @constructor\n * @extends module:zrender/mixin/Transformable\n * @extends module:zrender/mixin/Eventful\n */\nvar Group = function (opts) {\n  opts = opts || {};\n  Element.call(this, opts);\n\n  for (var key in opts) {\n    if (opts.hasOwnProperty(key)) {\n      this[key] = opts[key];\n    }\n  }\n\n  this._children = [];\n  this.__storage = null;\n  this.__dirty = true;\n};\n\nGroup.prototype = {\n  constructor: Group,\n  isGroup: true,\n\n  /**\n   * @type {string}\n   */\n  type: 'group',\n\n  /**\n   * 所有子孙元素是否响应鼠标事件\n   * @name module:/zrender/container/Group#silent\n   * @type {boolean}\n   * @default false\n   */\n  silent: false,\n\n  /**\n   * @return {Array.<module:zrender/Element>}\n   */\n  children: function () {\n    return this._children.slice();\n  },\n\n  /**\n   * 获取指定 index 的儿子节点\n   * @param  {number} idx\n   * @return {module:zrender/Element}\n   */\n  childAt: function (idx) {\n    return this._children[idx];\n  },\n\n  /**\n   * 获取指定名字的儿子节点\n   * @param  {string} name\n   * @return {module:zrender/Element}\n   */\n  childOfName: function (name) {\n    var children = this._children;\n\n    for (var i = 0; i < children.length; i++) {\n      if (children[i].name === name) {\n        return children[i];\n      }\n    }\n  },\n\n  /**\n   * @return {number}\n   */\n  childCount: function () {\n    return this._children.length;\n  },\n\n  /**\n   * 添加子节点到最后\n   * @param {module:zrender/Element} child\n   */\n  add: function (child) {\n    if (child && child !== this && child.parent !== this) {\n      this._children.push(child);\n\n      this._doAdd(child);\n    }\n\n    return this;\n  },\n\n  /**\n   * 添加子节点在 nextSibling 之前\n   * @param {module:zrender/Element} child\n   * @param {module:zrender/Element} nextSibling\n   */\n  addBefore: function (child, nextSibling) {\n    if (child && child !== this && child.parent !== this && nextSibling && nextSibling.parent === this) {\n      var children = this._children;\n      var idx = children.indexOf(nextSibling);\n\n      if (idx >= 0) {\n        children.splice(idx, 0, child);\n\n        this._doAdd(child);\n      }\n    }\n\n    return this;\n  },\n  _doAdd: function (child) {\n    if (child.parent) {\n      child.parent.remove(child);\n    }\n\n    child.parent = this;\n    var storage = this.__storage;\n    var zr = this.__zr;\n\n    if (storage && storage !== child.__storage) {\n      storage.addToStorage(child);\n\n      if (child instanceof Group) {\n        child.addChildrenToStorage(storage);\n      }\n    }\n\n    zr && zr.refresh();\n  },\n\n  /**\n   * 移除子节点\n   * @param {module:zrender/Element} child\n   */\n  remove: function (child) {\n    var zr = this.__zr;\n    var storage = this.__storage;\n    var children = this._children;\n    var idx = zrUtil.indexOf(children, child);\n\n    if (idx < 0) {\n      return this;\n    }\n\n    children.splice(idx, 1);\n    child.parent = null;\n\n    if (storage) {\n      storage.delFromStorage(child);\n\n      if (child instanceof Group) {\n        child.delChildrenFromStorage(storage);\n      }\n    }\n\n    zr && zr.refresh();\n    return this;\n  },\n\n  /**\n   * 移除所有子节点\n   */\n  removeAll: function () {\n    var children = this._children;\n    var storage = this.__storage;\n    var child;\n    var i;\n\n    for (i = 0; i < children.length; i++) {\n      child = children[i];\n\n      if (storage) {\n        storage.delFromStorage(child);\n\n        if (child instanceof Group) {\n          child.delChildrenFromStorage(storage);\n        }\n      }\n\n      child.parent = null;\n    }\n\n    children.length = 0;\n    return this;\n  },\n\n  /**\n   * 遍历所有子节点\n   * @param  {Function} cb\n   * @param  {}   context\n   */\n  eachChild: function (cb, context) {\n    var children = this._children;\n\n    for (var i = 0; i < children.length; i++) {\n      var child = children[i];\n      cb.call(context, child, i);\n    }\n\n    return this;\n  },\n\n  /**\n   * 深度优先遍历所有子孙节点\n   * @param  {Function} cb\n   * @param  {}   context\n   */\n  traverse: function (cb, context) {\n    for (var i = 0; i < this._children.length; i++) {\n      var child = this._children[i];\n      cb.call(context, child);\n\n      if (child.type === 'group') {\n        child.traverse(cb, context);\n      }\n    }\n\n    return this;\n  },\n  addChildrenToStorage: function (storage) {\n    for (var i = 0; i < this._children.length; i++) {\n      var child = this._children[i];\n      storage.addToStorage(child);\n\n      if (child instanceof Group) {\n        child.addChildrenToStorage(storage);\n      }\n    }\n  },\n  delChildrenFromStorage: function (storage) {\n    for (var i = 0; i < this._children.length; i++) {\n      var child = this._children[i];\n      storage.delFromStorage(child);\n\n      if (child instanceof Group) {\n        child.delChildrenFromStorage(storage);\n      }\n    }\n  },\n  dirty: function () {\n    this.__dirty = true;\n    this.__zr && this.__zr.refresh();\n    return this;\n  },\n\n  /**\n   * @return {module:zrender/core/BoundingRect}\n   */\n  getBoundingRect: function (includeChildren) {\n    // TODO Caching\n    var rect = null;\n    var tmpRect = new BoundingRect(0, 0, 0, 0);\n    var children = includeChildren || this._children;\n    var tmpMat = [];\n\n    for (var i = 0; i < children.length; i++) {\n      var child = children[i];\n\n      if (child.ignore || child.invisible) {\n        continue;\n      }\n\n      var childRect = child.getBoundingRect();\n      var transform = child.getLocalTransform(tmpMat); // TODO\n      // The boundingRect cacluated by transforming original\n      // rect may be bigger than the actual bundingRect when rotation\n      // is used. (Consider a circle rotated aginst its center, where\n      // the actual boundingRect should be the same as that not be\n      // rotated.) But we can not find better approach to calculate\n      // actual boundingRect yet, considering performance.\n\n      if (transform) {\n        tmpRect.copy(childRect);\n        tmpRect.applyTransform(transform);\n        rect = rect || tmpRect.clone();\n        rect.union(tmpRect);\n      } else {\n        rect = rect || childRect.clone();\n        rect.union(childRect);\n      }\n    }\n\n    return rect || tmpRect;\n  }\n};\nzrUtil.inherits(Group, Element);\nvar _default = Group;\nmodule.exports = _default;\n\n/***/ }),\n/* 62 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar Displayable = __webpack_require__(7);\n\nvar zrUtil = __webpack_require__(0);\n\nvar textContain = __webpack_require__(23);\n\nvar textHelper = __webpack_require__(22);\n\nvar _constant = __webpack_require__(8);\n\nvar ContextCachedBy = _constant.ContextCachedBy;\n\n/**\n * @alias zrender/graphic/Text\n * @extends module:zrender/graphic/Displayable\n * @constructor\n * @param {Object} opts\n */\nvar Text = function (opts) {\n  // jshint ignore:line\n  Displayable.call(this, opts);\n};\n\nText.prototype = {\n  constructor: Text,\n  type: 'text',\n  brush: function (ctx, prevEl) {\n    var style = this.style; // Optimize, avoid normalize every time.\n\n    this.__dirty && textHelper.normalizeTextStyle(style, true); // Use props with prefix 'text'.\n\n    style.fill = style.stroke = style.shadowBlur = style.shadowColor = style.shadowOffsetX = style.shadowOffsetY = null;\n    var text = style.text; // Convert to string\n\n    text != null && (text += ''); // Do not apply style.bind in Text node. Because the real bind job\n    // is in textHelper.renderText, and performance of text render should\n    // be considered.\n    // style.bind(ctx, this, prevEl);\n\n    if (!textHelper.needDrawText(text, style)) {\n      // The current el.style is not applied\n      // and should not be used as cache.\n      ctx.__attrCachedBy = ContextCachedBy.NONE;\n      return;\n    }\n\n    this.setTransform(ctx);\n    textHelper.renderText(this, ctx, text, style, null, prevEl);\n    this.restoreTransform(ctx);\n  },\n  getBoundingRect: function () {\n    var style = this.style; // Optimize, avoid normalize every time.\n\n    this.__dirty && textHelper.normalizeTextStyle(style, true);\n\n    if (!this._rect) {\n      var text = style.text;\n      text != null ? text += '' : text = '';\n      var rect = textContain.getBoundingRect(style.text + '', style.font, style.textAlign, style.textVerticalAlign, style.textPadding, style.textLineHeight, style.rich);\n      rect.x += style.x || 0;\n      rect.y += style.y || 0;\n\n      if (textHelper.getStroke(style.textStroke, style.textStrokeWidth)) {\n        var w = style.textStrokeWidth;\n        rect.x -= w / 2;\n        rect.y -= w / 2;\n        rect.width += w;\n        rect.height += w;\n      }\n\n      this._rect = rect;\n    }\n\n    return this._rect;\n  }\n};\nzrUtil.inherits(Text, Displayable);\nvar _default = Text;\nmodule.exports = _default;\n\n/***/ }),\n/* 63 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar Path = __webpack_require__(1);\n\n/**\n * 圆形\n * @module zrender/shape/Circle\n */\nvar _default = Path.extend({\n  type: 'circle',\n  shape: {\n    cx: 0,\n    cy: 0,\n    r: 0\n  },\n  buildPath: function (ctx, shape, inBundle) {\n    // Better stroking in ShapeBundle\n    // Always do it may have performence issue ( fill may be 2x more cost)\n    if (inBundle) {\n      ctx.moveTo(shape.cx + shape.r, shape.cy);\n    } // else {\n    //     if (ctx.allocate && !ctx.data.length) {\n    //         ctx.allocate(ctx.CMD_MEM_SIZE.A);\n    //     }\n    // }\n    // Better stroking in ShapeBundle\n    // ctx.moveTo(shape.cx + shape.r, shape.cy);\n\n\n    ctx.arc(shape.cx, shape.cy, shape.r, 0, Math.PI * 2, true);\n  }\n});\n\nmodule.exports = _default;\n\n/***/ }),\n/* 64 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar Path = __webpack_require__(1);\n\nvar fixClipWithShadow = __webpack_require__(65);\n\n/**\n * 扇形\n * @module zrender/graphic/shape/Sector\n */\nvar _default = Path.extend({\n  type: 'sector',\n  shape: {\n    cx: 0,\n    cy: 0,\n    r0: 0,\n    r: 0,\n    startAngle: 0,\n    endAngle: Math.PI * 2,\n    clockwise: true\n  },\n  brush: fixClipWithShadow(Path.prototype.brush),\n  buildPath: function (ctx, shape) {\n    var x = shape.cx;\n    var y = shape.cy;\n    var r0 = Math.max(shape.r0 || 0, 0);\n    var r = Math.max(shape.r, 0);\n    var startAngle = shape.startAngle;\n    var endAngle = shape.endAngle;\n    var clockwise = shape.clockwise;\n    var unitX = Math.cos(startAngle);\n    var unitY = Math.sin(startAngle);\n    ctx.moveTo(unitX * r0 + x, unitY * r0 + y);\n    ctx.lineTo(unitX * r + x, unitY * r + y);\n    ctx.arc(x, y, r, startAngle, endAngle, !clockwise);\n    ctx.lineTo(Math.cos(endAngle) * r0 + x, Math.sin(endAngle) * r0 + y);\n\n    if (r0 !== 0) {\n      ctx.arc(x, y, r0, endAngle, startAngle, clockwise);\n    }\n\n    ctx.closePath();\n  }\n});\n\nmodule.exports = _default;\n\n/***/ }),\n/* 65 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar env = __webpack_require__(13);\n\n// Fix weird bug in some version of IE11 (like 11.0.9600.178**),\n// where exception \"unexpected call to method or property access\"\n// might be thrown when calling ctx.fill or ctx.stroke after a path\n// whose area size is zero is drawn and ctx.clip() is called and\n// shadowBlur is set. See #4572, #3112, #5777.\n// (e.g.,\n//  ctx.moveTo(10, 10);\n//  ctx.lineTo(20, 10);\n//  ctx.closePath();\n//  ctx.clip();\n//  ctx.shadowBlur = 10;\n//  ...\n//  ctx.fill();\n// )\nvar shadowTemp = [['shadowBlur', 0], ['shadowColor', '#000'], ['shadowOffsetX', 0], ['shadowOffsetY', 0]];\n\nfunction _default(orignalBrush) {\n  // version string can be: '11.0'\n  return env.browser.ie && env.browser.version >= 11 ? function () {\n    var clipPaths = this.__clipPaths;\n    var style = this.style;\n    var modified;\n\n    if (clipPaths) {\n      for (var i = 0; i < clipPaths.length; i++) {\n        var clipPath = clipPaths[i];\n        var shape = clipPath && clipPath.shape;\n        var type = clipPath && clipPath.type;\n\n        if (shape && (type === 'sector' && shape.startAngle === shape.endAngle || type === 'rect' && (!shape.width || !shape.height))) {\n          for (var j = 0; j < shadowTemp.length; j++) {\n            // It is save to put shadowTemp static, because shadowTemp\n            // will be all modified each item brush called.\n            shadowTemp[j][2] = style[shadowTemp[j][0]];\n            style[shadowTemp[j][0]] = shadowTemp[j][1];\n          }\n\n          modified = true;\n          break;\n        }\n      }\n    }\n\n    orignalBrush.apply(this, arguments);\n\n    if (modified) {\n      for (var j = 0; j < shadowTemp.length; j++) {\n        style[shadowTemp[j][0]] = shadowTemp[j][2];\n      }\n    }\n  } : orignalBrush;\n}\n\nmodule.exports = _default;\n\n/***/ }),\n/* 66 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar Path = __webpack_require__(1);\n\n/**\n * 圆环\n * @module zrender/graphic/shape/Ring\n */\nvar _default = Path.extend({\n  type: 'ring',\n  shape: {\n    cx: 0,\n    cy: 0,\n    r: 0,\n    r0: 0\n  },\n  buildPath: function (ctx, shape) {\n    var x = shape.cx;\n    var y = shape.cy;\n    var PI2 = Math.PI * 2;\n    ctx.moveTo(x + shape.r, y);\n    ctx.arc(x, y, shape.r, 0, PI2, false);\n    ctx.moveTo(x + shape.r0, y);\n    ctx.arc(x, y, shape.r0, 0, PI2, true);\n  }\n});\n\nmodule.exports = _default;\n\n/***/ }),\n/* 67 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar Path = __webpack_require__(1);\n\nvar polyHelper = __webpack_require__(26);\n\n/**\n * 多边形\n * @module zrender/shape/Polygon\n */\nvar _default = Path.extend({\n  type: 'polygon',\n  shape: {\n    points: null,\n    smooth: false,\n    smoothConstraint: null\n  },\n  buildPath: function (ctx, shape) {\n    polyHelper.buildPath(ctx, shape, true);\n  }\n});\n\nmodule.exports = _default;\n\n/***/ }),\n/* 68 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar _vector = __webpack_require__(2);\n\nvar v2Distance = _vector.distance;\n\n/**\n * Catmull-Rom spline 插值折线\n * @module zrender/shape/util/smoothSpline\n * @author pissang (https://www.github.com/pissang)\n *         Kener (@Kener-林峰, kener.linfeng@gmail.com)\n *         errorrik (errorrik@gmail.com)\n */\n\n/**\n * @inner\n */\nfunction interpolate(p0, p1, p2, p3, t, t2, t3) {\n  var v0 = (p2 - p0) * 0.5;\n  var v1 = (p3 - p1) * 0.5;\n  return (2 * (p1 - p2) + v0 + v1) * t3 + (-3 * (p1 - p2) - 2 * v0 - v1) * t2 + v0 * t + p1;\n}\n/**\n * @alias module:zrender/shape/util/smoothSpline\n * @param {Array} points 线段顶点数组\n * @param {boolean} isLoop\n * @return {Array}\n */\n\n\nfunction _default(points, isLoop) {\n  var len = points.length;\n  var ret = [];\n  var distance = 0;\n\n  for (var i = 1; i < len; i++) {\n    distance += v2Distance(points[i - 1], points[i]);\n  }\n\n  var segs = distance / 2;\n  segs = segs < len ? len : segs;\n\n  for (var i = 0; i < segs; i++) {\n    var pos = i / (segs - 1) * (isLoop ? len : len - 1);\n    var idx = Math.floor(pos);\n    var w = pos - idx;\n    var p0;\n    var p1 = points[idx % len];\n    var p2;\n    var p3;\n\n    if (!isLoop) {\n      p0 = points[idx === 0 ? idx : idx - 1];\n      p2 = points[idx > len - 2 ? len - 1 : idx + 1];\n      p3 = points[idx > len - 3 ? len - 1 : idx + 2];\n    } else {\n      p0 = points[(idx - 1 + len) % len];\n      p2 = points[(idx + 1) % len];\n      p3 = points[(idx + 2) % len];\n    }\n\n    var w2 = w * w;\n    var w3 = w * w2;\n    ret.push([interpolate(p0[0], p1[0], p2[0], p3[0], w, w2, w3), interpolate(p0[1], p1[1], p2[1], p3[1], w, w2, w3)]);\n  }\n\n  return ret;\n}\n\nmodule.exports = _default;\n\n/***/ }),\n/* 69 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar _vector = __webpack_require__(2);\n\nvar v2Min = _vector.min;\nvar v2Max = _vector.max;\nvar v2Scale = _vector.scale;\nvar v2Distance = _vector.distance;\nvar v2Add = _vector.add;\nvar v2Clone = _vector.clone;\nvar v2Sub = _vector.sub;\n\n/**\n * 贝塞尔平滑曲线\n * @module zrender/shape/util/smoothBezier\n * @author pissang (https://www.github.com/pissang)\n *         Kener (@Kener-林峰, kener.linfeng@gmail.com)\n *         errorrik (errorrik@gmail.com)\n */\n\n/**\n * 贝塞尔平滑曲线\n * @alias module:zrender/shape/util/smoothBezier\n * @param {Array} points 线段顶点数组\n * @param {number} smooth 平滑等级, 0-1\n * @param {boolean} isLoop\n * @param {Array} constraint 将计算出来的控制点约束在一个包围盒内\n *                           比如 [[0, 0], [100, 100]], 这个包围盒会与\n *                           整个折线的包围盒做一个并集用来约束控制点。\n * @param {Array} 计算出来的控制点数组\n */\nfunction _default(points, smooth, isLoop, constraint) {\n  var cps = [];\n  var v = [];\n  var v1 = [];\n  var v2 = [];\n  var prevPoint;\n  var nextPoint;\n  var min;\n  var max;\n\n  if (constraint) {\n    min = [Infinity, Infinity];\n    max = [-Infinity, -Infinity];\n\n    for (var i = 0, len = points.length; i < len; i++) {\n      v2Min(min, min, points[i]);\n      v2Max(max, max, points[i]);\n    } // 与指定的包围盒做并集\n\n\n    v2Min(min, min, constraint[0]);\n    v2Max(max, max, constraint[1]);\n  }\n\n  for (var i = 0, len = points.length; i < len; i++) {\n    var point = points[i];\n\n    if (isLoop) {\n      prevPoint = points[i ? i - 1 : len - 1];\n      nextPoint = points[(i + 1) % len];\n    } else {\n      if (i === 0 || i === len - 1) {\n        cps.push(v2Clone(points[i]));\n        continue;\n      } else {\n        prevPoint = points[i - 1];\n        nextPoint = points[i + 1];\n      }\n    }\n\n    v2Sub(v, nextPoint, prevPoint); // use degree to scale the handle length\n\n    v2Scale(v, v, smooth);\n    var d0 = v2Distance(point, prevPoint);\n    var d1 = v2Distance(point, nextPoint);\n    var sum = d0 + d1;\n\n    if (sum !== 0) {\n      d0 /= sum;\n      d1 /= sum;\n    }\n\n    v2Scale(v1, v, -d0);\n    v2Scale(v2, v, d1);\n    var cp0 = v2Add([], point, v1);\n    var cp1 = v2Add([], point, v2);\n\n    if (constraint) {\n      v2Max(cp0, cp0, min);\n      v2Min(cp0, cp0, max);\n      v2Max(cp1, cp1, min);\n      v2Min(cp1, cp1, max);\n    }\n\n    cps.push(cp0);\n    cps.push(cp1);\n  }\n\n  if (isLoop) {\n    cps.push(cps.shift());\n  }\n\n  return cps;\n}\n\nmodule.exports = _default;\n\n/***/ }),\n/* 70 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar Path = __webpack_require__(1);\n\nvar polyHelper = __webpack_require__(26);\n\n/**\n * @module zrender/graphic/shape/Polyline\n */\nvar _default = Path.extend({\n  type: 'polyline',\n  shape: {\n    points: null,\n    smooth: false,\n    smoothConstraint: null\n  },\n  style: {\n    stroke: '#000',\n    fill: null\n  },\n  buildPath: function (ctx, shape) {\n    polyHelper.buildPath(ctx, shape, false);\n  }\n});\n\nmodule.exports = _default;\n\n/***/ }),\n/* 71 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar Path = __webpack_require__(1);\n\nvar roundRectHelper = __webpack_require__(24);\n\nvar _subPixelOptimize = __webpack_require__(27);\n\nvar subPixelOptimizeRect = _subPixelOptimize.subPixelOptimizeRect;\n\n/**\n * 矩形\n * @module zrender/graphic/shape/Rect\n */\n// Avoid create repeatly.\nvar subPixelOptimizeOutputShape = {};\n\nvar _default = Path.extend({\n  type: 'rect',\n  shape: {\n    // 左上、右上、右下、左下角的半径依次为r1、r2、r3、r4\n    // r缩写为1         相当于 [1, 1, 1, 1]\n    // r缩写为[1]       相当于 [1, 1, 1, 1]\n    // r缩写为[1, 2]    相当于 [1, 2, 1, 2]\n    // r缩写为[1, 2, 3] 相当于 [1, 2, 3, 2]\n    r: 0,\n    x: 0,\n    y: 0,\n    width: 0,\n    height: 0\n  },\n  buildPath: function (ctx, shape) {\n    var x;\n    var y;\n    var width;\n    var height;\n\n    if (this.subPixelOptimize) {\n      subPixelOptimizeRect(subPixelOptimizeOutputShape, shape, this.style);\n      x = subPixelOptimizeOutputShape.x;\n      y = subPixelOptimizeOutputShape.y;\n      width = subPixelOptimizeOutputShape.width;\n      height = subPixelOptimizeOutputShape.height;\n      subPixelOptimizeOutputShape.r = shape.r;\n      shape = subPixelOptimizeOutputShape;\n    } else {\n      x = shape.x;\n      y = shape.y;\n      width = shape.width;\n      height = shape.height;\n    }\n\n    if (!shape.r) {\n      ctx.rect(x, y, width, height);\n    } else {\n      roundRectHelper.buildPath(ctx, shape);\n    }\n\n    ctx.closePath();\n    return;\n  }\n});\n\nmodule.exports = _default;\n\n/***/ }),\n/* 72 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar Path = __webpack_require__(1);\n\nvar _subPixelOptimize = __webpack_require__(27);\n\nvar subPixelOptimizeLine = _subPixelOptimize.subPixelOptimizeLine;\n\n/**\n * 直线\n * @module zrender/graphic/shape/Line\n */\n// Avoid create repeatly.\nvar subPixelOptimizeOutputShape = {};\n\nvar _default = Path.extend({\n  type: 'line',\n  shape: {\n    // Start point\n    x1: 0,\n    y1: 0,\n    // End point\n    x2: 0,\n    y2: 0,\n    percent: 1\n  },\n  style: {\n    stroke: '#000',\n    fill: null\n  },\n  buildPath: function (ctx, shape) {\n    var x1;\n    var y1;\n    var x2;\n    var y2;\n\n    if (this.subPixelOptimize) {\n      subPixelOptimizeLine(subPixelOptimizeOutputShape, shape, this.style);\n      x1 = subPixelOptimizeOutputShape.x1;\n      y1 = subPixelOptimizeOutputShape.y1;\n      x2 = subPixelOptimizeOutputShape.x2;\n      y2 = subPixelOptimizeOutputShape.y2;\n    } else {\n      x1 = shape.x1;\n      y1 = shape.y1;\n      x2 = shape.x2;\n      y2 = shape.y2;\n    }\n\n    var percent = shape.percent;\n\n    if (percent === 0) {\n      return;\n    }\n\n    ctx.moveTo(x1, y1);\n\n    if (percent < 1) {\n      x2 = x1 * (1 - percent) + x2 * percent;\n      y2 = y1 * (1 - percent) + y2 * percent;\n    }\n\n    ctx.lineTo(x2, y2);\n  },\n\n  /**\n   * Get point at percent\n   * @param  {number} percent\n   * @return {Array.<number>}\n   */\n  pointAt: function (p) {\n    var shape = this.shape;\n    return [shape.x1 * (1 - p) + shape.x2 * p, shape.y1 * (1 - p) + shape.y2 * p];\n  }\n});\n\nmodule.exports = _default;\n\n/***/ }),\n/* 73 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar Path = __webpack_require__(1);\n\nvar vec2 = __webpack_require__(2);\n\nvar _curve = __webpack_require__(4);\n\nvar quadraticSubdivide = _curve.quadraticSubdivide;\nvar cubicSubdivide = _curve.cubicSubdivide;\nvar quadraticAt = _curve.quadraticAt;\nvar cubicAt = _curve.cubicAt;\nvar quadraticDerivativeAt = _curve.quadraticDerivativeAt;\nvar cubicDerivativeAt = _curve.cubicDerivativeAt;\n\n/**\n * 贝塞尔曲线\n * @module zrender/shape/BezierCurve\n */\nvar out = [];\n\nfunction someVectorAt(shape, t, isTangent) {\n  var cpx2 = shape.cpx2;\n  var cpy2 = shape.cpy2;\n\n  if (cpx2 === null || cpy2 === null) {\n    return [(isTangent ? cubicDerivativeAt : cubicAt)(shape.x1, shape.cpx1, shape.cpx2, shape.x2, t), (isTangent ? cubicDerivativeAt : cubicAt)(shape.y1, shape.cpy1, shape.cpy2, shape.y2, t)];\n  } else {\n    return [(isTangent ? quadraticDerivativeAt : quadraticAt)(shape.x1, shape.cpx1, shape.x2, t), (isTangent ? quadraticDerivativeAt : quadraticAt)(shape.y1, shape.cpy1, shape.y2, t)];\n  }\n}\n\nvar _default = Path.extend({\n  type: 'bezier-curve',\n  shape: {\n    x1: 0,\n    y1: 0,\n    x2: 0,\n    y2: 0,\n    cpx1: 0,\n    cpy1: 0,\n    // cpx2: 0,\n    // cpy2: 0\n    // Curve show percent, for animating\n    percent: 1\n  },\n  style: {\n    stroke: '#000',\n    fill: null\n  },\n  buildPath: function (ctx, shape) {\n    var x1 = shape.x1;\n    var y1 = shape.y1;\n    var x2 = shape.x2;\n    var y2 = shape.y2;\n    var cpx1 = shape.cpx1;\n    var cpy1 = shape.cpy1;\n    var cpx2 = shape.cpx2;\n    var cpy2 = shape.cpy2;\n    var percent = shape.percent;\n\n    if (percent === 0) {\n      return;\n    }\n\n    ctx.moveTo(x1, y1);\n\n    if (cpx2 == null || cpy2 == null) {\n      if (percent < 1) {\n        quadraticSubdivide(x1, cpx1, x2, percent, out);\n        cpx1 = out[1];\n        x2 = out[2];\n        quadraticSubdivide(y1, cpy1, y2, percent, out);\n        cpy1 = out[1];\n        y2 = out[2];\n      }\n\n      ctx.quadraticCurveTo(cpx1, cpy1, x2, y2);\n    } else {\n      if (percent < 1) {\n        cubicSubdivide(x1, cpx1, cpx2, x2, percent, out);\n        cpx1 = out[1];\n        cpx2 = out[2];\n        x2 = out[3];\n        cubicSubdivide(y1, cpy1, cpy2, y2, percent, out);\n        cpy1 = out[1];\n        cpy2 = out[2];\n        y2 = out[3];\n      }\n\n      ctx.bezierCurveTo(cpx1, cpy1, cpx2, cpy2, x2, y2);\n    }\n  },\n\n  /**\n   * Get point at percent\n   * @param  {number} t\n   * @return {Array.<number>}\n   */\n  pointAt: function (t) {\n    return someVectorAt(this.shape, t, false);\n  },\n\n  /**\n   * Get tangent at percent\n   * @param  {number} t\n   * @return {Array.<number>}\n   */\n  tangentAt: function (t) {\n    var p = someVectorAt(this.shape, t, true);\n    return vec2.normalize(p, p);\n  }\n});\n\nmodule.exports = _default;\n\n/***/ }),\n/* 74 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar Path = __webpack_require__(1);\n\n/**\n * 圆弧\n * @module zrender/graphic/shape/Arc\n */\nvar _default = Path.extend({\n  type: 'arc',\n  shape: {\n    cx: 0,\n    cy: 0,\n    r: 0,\n    startAngle: 0,\n    endAngle: Math.PI * 2,\n    clockwise: true\n  },\n  style: {\n    stroke: '#000',\n    fill: null\n  },\n  buildPath: function (ctx, shape) {\n    var x = shape.cx;\n    var y = shape.cy;\n    var r = Math.max(shape.r, 0);\n    var startAngle = shape.startAngle;\n    var endAngle = shape.endAngle;\n    var clockwise = shape.clockwise;\n    var unitX = Math.cos(startAngle);\n    var unitY = Math.sin(startAngle);\n    ctx.moveTo(unitX * r + x, unitY * r + y);\n    ctx.arc(x, y, r, startAngle, endAngle, !clockwise);\n  }\n});\n\nmodule.exports = _default;\n\n/***/ }),\n/* 75 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar Path = __webpack_require__(1);\n\n// CompoundPath to improve performance\nvar _default = Path.extend({\n  type: 'compound',\n  shape: {\n    paths: null\n  },\n  _updatePathDirty: function () {\n    var dirtyPath = this.__dirtyPath;\n    var paths = this.shape.paths;\n\n    for (var i = 0; i < paths.length; i++) {\n      // Mark as dirty if any subpath is dirty\n      dirtyPath = dirtyPath || paths[i].__dirtyPath;\n    }\n\n    this.__dirtyPath = dirtyPath;\n    this.__dirty = this.__dirty || dirtyPath;\n  },\n  beforeBrush: function () {\n    this._updatePathDirty();\n\n    var paths = this.shape.paths || [];\n    var scale = this.getGlobalScale(); // Update path scale\n\n    for (var i = 0; i < paths.length; i++) {\n      if (!paths[i].path) {\n        paths[i].createPathProxy();\n      }\n\n      paths[i].path.setScale(scale[0], scale[1]);\n    }\n  },\n  buildPath: function (ctx, shape) {\n    var paths = shape.paths || [];\n\n    for (var i = 0; i < paths.length; i++) {\n      paths[i].buildPath(ctx, paths[i].shape, true);\n    }\n  },\n  afterBrush: function () {\n    var paths = this.shape.paths || [];\n\n    for (var i = 0; i < paths.length; i++) {\n      paths[i].__dirtyPath = false;\n    }\n  },\n  getBoundingRect: function () {\n    this._updatePathDirty();\n\n    return Path.prototype.getBoundingRect.call(this);\n  }\n});\n\nmodule.exports = _default;\n\n/***/ }),\n/* 76 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar zrUtil = __webpack_require__(0);\n\nvar Gradient = __webpack_require__(28);\n\n/**\n * x, y, x2, y2 are all percent from 0 to 1\n * @param {number} [x=0]\n * @param {number} [y=0]\n * @param {number} [x2=1]\n * @param {number} [y2=0]\n * @param {Array.<Object>} colorStops\n * @param {boolean} [globalCoord=false]\n */\nvar LinearGradient = function (x, y, x2, y2, colorStops, globalCoord) {\n  // Should do nothing more in this constructor. Because gradient can be\n  // declard by `color: {type: 'linear', colorStops: ...}`, where\n  // this constructor will not be called.\n  this.x = x == null ? 0 : x;\n  this.y = y == null ? 0 : y;\n  this.x2 = x2 == null ? 1 : x2;\n  this.y2 = y2 == null ? 0 : y2; // Can be cloned\n\n  this.type = 'linear'; // If use global coord\n\n  this.global = globalCoord || false;\n  Gradient.call(this, colorStops);\n};\n\nLinearGradient.prototype = {\n  constructor: LinearGradient\n};\nzrUtil.inherits(LinearGradient, Gradient);\nvar _default = LinearGradient;\nmodule.exports = _default;\n\n/***/ }),\n/* 77 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar zrUtil = __webpack_require__(0);\n\nvar Gradient = __webpack_require__(28);\n\n/**\n * x, y, r are all percent from 0 to 1\n * @param {number} [x=0.5]\n * @param {number} [y=0.5]\n * @param {number} [r=0.5]\n * @param {Array.<Object>} [colorStops]\n * @param {boolean} [globalCoord=false]\n */\nvar RadialGradient = function (x, y, r, colorStops, globalCoord) {\n  // Should do nothing more in this constructor. Because gradient can be\n  // declard by `color: {type: 'radial', colorStops: ...}`, where\n  // this constructor will not be called.\n  this.x = x == null ? 0.5 : x;\n  this.y = y == null ? 0.5 : y;\n  this.r = r == null ? 0.5 : r; // Can be cloned\n\n  this.type = 'radial'; // If use global coord\n\n  this.global = globalCoord || false;\n  Gradient.call(this, colorStops);\n};\n\nRadialGradient.prototype = {\n  constructor: RadialGradient\n};\nzrUtil.inherits(RadialGradient, Gradient);\nvar _default = RadialGradient;\nmodule.exports = _default;\n\n/***/ }),\n/* 78 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar _util = __webpack_require__(0);\n\nvar inherits = _util.inherits;\n\nvar Displayble = __webpack_require__(7);\n\nvar BoundingRect = __webpack_require__(3);\n\n/**\n * Displayable for incremental rendering. It will be rendered in a separate layer\n * IncrementalDisplay have two main methods. `clearDisplayables` and `addDisplayables`\n * addDisplayables will render the added displayables incremetally.\n *\n * It use a not clearFlag to tell the painter don't clear the layer if it's the first element.\n */\n// TODO Style override ?\nfunction IncrementalDisplayble(opts) {\n  Displayble.call(this, opts);\n  this._displayables = [];\n  this._temporaryDisplayables = [];\n  this._cursor = 0;\n  this.notClear = true;\n}\n\nIncrementalDisplayble.prototype.incremental = true;\n\nIncrementalDisplayble.prototype.clearDisplaybles = function () {\n  this._displayables = [];\n  this._temporaryDisplayables = [];\n  this._cursor = 0;\n  this.dirty();\n  this.notClear = false;\n};\n\nIncrementalDisplayble.prototype.addDisplayable = function (displayable, notPersistent) {\n  if (notPersistent) {\n    this._temporaryDisplayables.push(displayable);\n  } else {\n    this._displayables.push(displayable);\n  }\n\n  this.dirty();\n};\n\nIncrementalDisplayble.prototype.addDisplayables = function (displayables, notPersistent) {\n  notPersistent = notPersistent || false;\n\n  for (var i = 0; i < displayables.length; i++) {\n    this.addDisplayable(displayables[i], notPersistent);\n  }\n};\n\nIncrementalDisplayble.prototype.eachPendingDisplayable = function (cb) {\n  for (var i = this._cursor; i < this._displayables.length; i++) {\n    cb && cb(this._displayables[i]);\n  }\n\n  for (var i = 0; i < this._temporaryDisplayables.length; i++) {\n    cb && cb(this._temporaryDisplayables[i]);\n  }\n};\n\nIncrementalDisplayble.prototype.update = function () {\n  this.updateTransform();\n\n  for (var i = this._cursor; i < this._displayables.length; i++) {\n    var displayable = this._displayables[i]; // PENDING\n\n    displayable.parent = this;\n    displayable.update();\n    displayable.parent = null;\n  }\n\n  for (var i = 0; i < this._temporaryDisplayables.length; i++) {\n    var displayable = this._temporaryDisplayables[i]; // PENDING\n\n    displayable.parent = this;\n    displayable.update();\n    displayable.parent = null;\n  }\n};\n\nIncrementalDisplayble.prototype.brush = function (ctx, prevEl) {\n  // Render persistant displayables.\n  for (var i = this._cursor; i < this._displayables.length; i++) {\n    var displayable = this._displayables[i];\n    displayable.beforeBrush && displayable.beforeBrush(ctx);\n    displayable.brush(ctx, i === this._cursor ? null : this._displayables[i - 1]);\n    displayable.afterBrush && displayable.afterBrush(ctx);\n  }\n\n  this._cursor = i; // Render temporary displayables.\n\n  for (var i = 0; i < this._temporaryDisplayables.length; i++) {\n    var displayable = this._temporaryDisplayables[i];\n    displayable.beforeBrush && displayable.beforeBrush(ctx);\n    displayable.brush(ctx, i === 0 ? null : this._temporaryDisplayables[i - 1]);\n    displayable.afterBrush && displayable.afterBrush(ctx);\n  }\n\n  this._temporaryDisplayables = [];\n  this.notClear = true;\n};\n\nvar m = [];\n\nIncrementalDisplayble.prototype.getBoundingRect = function () {\n  if (!this._rect) {\n    var rect = new BoundingRect(Infinity, Infinity, -Infinity, -Infinity);\n\n    for (var i = 0; i < this._displayables.length; i++) {\n      var displayable = this._displayables[i];\n      var childRect = displayable.getBoundingRect().clone();\n\n      if (displayable.needLocalTransform()) {\n        childRect.applyTransform(displayable.getLocalTransform(m));\n      }\n\n      rect.union(childRect);\n    }\n\n    this._rect = rect;\n  }\n\n  return this._rect;\n};\n\nIncrementalDisplayble.prototype.contain = function (x, y) {\n  var localPos = this.transformCoordToLocal(x, y);\n  var rect = this.getBoundingRect();\n\n  if (rect.contain(localPos[0], localPos[1])) {\n    for (var i = 0; i < this._displayables.length; i++) {\n      var displayable = this._displayables[i];\n\n      if (displayable.contain(x, y)) {\n        return true;\n      }\n    }\n  }\n\n  return false;\n};\n\ninherits(IncrementalDisplayble, Displayble);\nvar _default = IncrementalDisplayble;\nmodule.exports = _default;\n\n/***/ }),\n/* 79 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar echarts = __webpack_require__(5);\n\nmodule.exports = echarts.graphic.extendShape({\n    type: 'ec-liquid-fill',\n\n    shape: {\n        waveLength: 0,\n        radius: 0,\n        radiusY: 0,\n        cx: 0,\n        cy: 0,\n        waterLevel: 0,\n        amplitude: 0,\n        phase: 0,\n        inverse: false\n    },\n\n    buildPath: function (ctx, shape) {\n        if (shape.radiusY == null) {\n            shape.radiusY = shape.radius;\n        }\n\n        /**\n         * We define a sine wave having 4 waves, and make sure at least 8 curves\n         * is drawn. Otherwise, it may cause blank area for some waves when\n         * wave length is large enough.\n         */\n        var curves = Math.max(\n            Math.ceil(2 * shape.radius / shape.waveLength * 4) * 2,\n            8\n        );\n\n        // map phase to [-Math.PI * 2, 0]\n        while (shape.phase < -Math.PI * 2) {\n            shape.phase += Math.PI * 2;\n        }\n        while (shape.phase > 0) {\n            shape.phase -= Math.PI * 2;\n        }\n        var phase = shape.phase / Math.PI / 2 * shape.waveLength;\n\n        var left = shape.cx - shape.radius + phase - shape.radius * 2;\n\n        /**\n         * top-left corner as start point\n         *\n         * draws this point\n         *  |\n         * \\|/\n         *  ~~~~~~~~\n         *  |      |\n         *  +------+\n         */\n        ctx.moveTo(left, shape.waterLevel);\n\n        /**\n         * top wave\n         *\n         * ~~~~~~~~ <- draws this sine wave\n         * |      |\n         * +------+\n         */\n        var waveRight = 0;\n        for (var c = 0; c < curves; ++c) {\n            var stage = c % 4;\n            var pos = getWaterPositions(c * shape.waveLength / 4, stage,\n                shape.waveLength, shape.amplitude);\n            ctx.bezierCurveTo(pos[0][0] + left, -pos[0][1] + shape.waterLevel,\n                pos[1][0] + left, -pos[1][1] + shape.waterLevel,\n                pos[2][0] + left, -pos[2][1] + shape.waterLevel);\n\n            if (c === curves - 1) {\n                waveRight = pos[2][0];\n            }\n        }\n\n        if (shape.inverse) {\n            /**\n             * top-right corner\n             *                  2. draws this line\n             *                          |\n             *                       +------+\n             * 3. draws this line -> |      | <- 1. draws this line\n             *                       ~~~~~~~~\n             */\n            ctx.lineTo(waveRight + left, shape.cy - shape.radiusY);\n            ctx.lineTo(left, shape.cy - shape.radiusY);\n            ctx.lineTo(left, shape.waterLevel);\n        }\n        else {\n            /**\n             * top-right corner\n             *\n             *                       ~~~~~~~~\n             * 3. draws this line -> |      | <- 1. draws this line\n             *                       +------+\n             *                          ^\n             *                          |\n             *                  2. draws this line\n             */\n            ctx.lineTo(waveRight + left, shape.cy + shape.radiusY);\n            ctx.lineTo(left, shape.cy + shape.radiusY);\n            ctx.lineTo(left, shape.waterLevel);\n        }\n\n        ctx.closePath();\n    }\n});\n\n\n\n/**\n * Using Bezier curves to fit sine wave.\n * There is 4 control points for each curve of wave,\n * which is at 1/4 wave length of the sine wave.\n *\n * The control points for a wave from (a) to (d) are a-b-c-d:\n *          c *----* d\n *     b *\n *       |\n * ... a * ..................\n *\n * whose positions are a: (0, 0), b: (0.5, 0.5), c: (1, 1), d: (PI / 2, 1)\n *\n * @param {number} x          x position of the left-most point (a)\n * @param {number} stage      0-3, stating which part of the wave it is\n * @param {number} waveLength wave length of the sine wave\n * @param {number} amplitude  wave amplitude\n */\nfunction getWaterPositions(x, stage, waveLength, amplitude) {\n    if (stage === 0) {\n        return [\n            [x + 1 / 2 * waveLength / Math.PI / 2, amplitude / 2],\n            [x + 1 / 2 * waveLength / Math.PI,     amplitude],\n            [x + waveLength / 4,                   amplitude]\n        ];\n    }\n    else if (stage === 1) {\n        return [\n            [x + 1 / 2 * waveLength / Math.PI / 2 * (Math.PI - 2),\n            amplitude],\n            [x + 1 / 2 * waveLength / Math.PI / 2 * (Math.PI - 1),\n            amplitude / 2],\n            [x + waveLength / 4,                   0]\n        ]\n    }\n    else if (stage === 2) {\n        return [\n            [x + 1 / 2 * waveLength / Math.PI / 2, -amplitude / 2],\n            [x + 1 / 2 * waveLength / Math.PI,     -amplitude],\n            [x + waveLength / 4,                   -amplitude]\n        ]\n    }\n    else {\n        return [\n            [x + 1 / 2 * waveLength / Math.PI / 2 * (Math.PI - 2),\n            -amplitude],\n            [x + 1 / 2 * waveLength / Math.PI / 2 * (Math.PI - 1),\n            -amplitude / 2],\n            [x + waveLength / 4,                   0]\n        ]\n    }\n}\n\n\n/***/ }),\n/* 80 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar _util = __webpack_require__(0);\n\nvar createHashMap = _util.createHashMap;\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n// Pick color from palette for each data item.\n// Applicable for charts that require applying color palette\n// in data level (like pie, funnel, chord).\nfunction _default(seriesType) {\n  return {\n    getTargetSeries: function (ecModel) {\n      // Pie and funnel may use diferrent scope\n      var paletteScope = {};\n      var seiresModelMap = createHashMap();\n      ecModel.eachSeriesByType(seriesType, function (seriesModel) {\n        seriesModel.__paletteScope = paletteScope;\n        seiresModelMap.set(seriesModel.uid, seriesModel);\n      });\n      return seiresModelMap;\n    },\n    reset: function (seriesModel, ecModel) {\n      var dataAll = seriesModel.getRawData();\n      var idxMap = {};\n      var data = seriesModel.getData();\n      data.each(function (idx) {\n        var rawIdx = data.getRawIndex(idx);\n        idxMap[rawIdx] = idx;\n      });\n      dataAll.each(function (rawIdx) {\n        var filteredIdx = idxMap[rawIdx]; // If series.itemStyle.normal.color is a function. itemVisual may be encoded\n\n        var singleDataColor = filteredIdx != null && data.getItemVisual(filteredIdx, 'color', true);\n\n        if (!singleDataColor) {\n          // FIXME Performance\n          var itemModel = dataAll.getItemModel(rawIdx);\n          var color = itemModel.get('itemStyle.color') || seriesModel.getColorFromPalette(dataAll.getName(rawIdx) || rawIdx + '', seriesModel.__paletteScope, dataAll.count()); // Legend may use the visual info in data before processed\n\n          dataAll.setItemVisual(rawIdx, 'color', color); // Data is not filtered\n\n          if (filteredIdx != null) {\n            data.setItemVisual(filteredIdx, 'color', color);\n          }\n        } else {\n          // Set data all color for legend\n          dataAll.setItemVisual(rawIdx, 'color', singleDataColor);\n        }\n      });\n    }\n  };\n}\n\nmodule.exports = _default;\n\n/***/ })\n/******/ ]);\n});"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 29);\n","/**\n * @module zrender/core/util\n */\n// 用于处理merge时无法遍历Date等对象的问题\nvar BUILTIN_OBJECT = {\n  '[object Function]': 1,\n  '[object RegExp]': 1,\n  '[object Date]': 1,\n  '[object Error]': 1,\n  '[object CanvasGradient]': 1,\n  '[object CanvasPattern]': 1,\n  // For node-canvas\n  '[object Image]': 1,\n  '[object Canvas]': 1\n};\nvar TYPED_ARRAY = {\n  '[object Int8Array]': 1,\n  '[object Uint8Array]': 1,\n  '[object Uint8ClampedArray]': 1,\n  '[object Int16Array]': 1,\n  '[object Uint16Array]': 1,\n  '[object Int32Array]': 1,\n  '[object Uint32Array]': 1,\n  '[object Float32Array]': 1,\n  '[object Float64Array]': 1\n};\nvar objToString = Object.prototype.toString;\nvar arrayProto = Array.prototype;\nvar nativeForEach = arrayProto.forEach;\nvar nativeFilter = arrayProto.filter;\nvar nativeSlice = arrayProto.slice;\nvar nativeMap = arrayProto.map;\nvar nativeReduce = arrayProto.reduce; // Avoid assign to an exported variable, for transforming to cjs.\n\nvar methods = {};\n\nfunction $override(name, fn) {\n  // Clear ctx instance for different environment\n  if (name === 'createCanvas') {\n    _ctx = null;\n  }\n\n  methods[name] = fn;\n}\n/**\n * Those data types can be cloned:\n *     Plain object, Array, TypedArray, number, string, null, undefined.\n * Those data types will be assgined using the orginal data:\n *     BUILTIN_OBJECT\n * Instance of user defined class will be cloned to a plain object, without\n * properties in prototype.\n * Other data types is not supported (not sure what will happen).\n *\n * Caution: do not support clone Date, for performance consideration.\n * (There might be a large number of date in `series.data`).\n * So date should not be modified in and out of echarts.\n *\n * @param {*} source\n * @return {*} new\n */\n\n\nfunction clone(source) {\n  if (source == null || typeof source !== 'object') {\n    return source;\n  }\n\n  var result = source;\n  var typeStr = objToString.call(source);\n\n  if (typeStr === '[object Array]') {\n    if (!isPrimitive(source)) {\n      result = [];\n\n      for (var i = 0, len = source.length; i < len; i++) {\n        result[i] = clone(source[i]);\n      }\n    }\n  } else if (TYPED_ARRAY[typeStr]) {\n    if (!isPrimitive(source)) {\n      var Ctor = source.constructor;\n\n      if (source.constructor.from) {\n        result = Ctor.from(source);\n      } else {\n        result = new Ctor(source.length);\n\n        for (var i = 0, len = source.length; i < len; i++) {\n          result[i] = clone(source[i]);\n        }\n      }\n    }\n  } else if (!BUILTIN_OBJECT[typeStr] && !isPrimitive(source) && !isDom(source)) {\n    result = {};\n\n    for (var key in source) {\n      if (source.hasOwnProperty(key)) {\n        result[key] = clone(source[key]);\n      }\n    }\n  }\n\n  return result;\n}\n/**\n * @memberOf module:zrender/core/util\n * @param {*} target\n * @param {*} source\n * @param {boolean} [overwrite=false]\n */\n\n\nfunction merge(target, source, overwrite) {\n  // We should escapse that source is string\n  // and enter for ... in ...\n  if (!isObject(source) || !isObject(target)) {\n    return overwrite ? clone(source) : target;\n  }\n\n  for (var key in source) {\n    if (source.hasOwnProperty(key)) {\n      var targetProp = target[key];\n      var sourceProp = source[key];\n\n      if (isObject(sourceProp) && isObject(targetProp) && !isArray(sourceProp) && !isArray(targetProp) && !isDom(sourceProp) && !isDom(targetProp) && !isBuiltInObject(sourceProp) && !isBuiltInObject(targetProp) && !isPrimitive(sourceProp) && !isPrimitive(targetProp)) {\n        // 如果需要递归覆盖，就递归调用merge\n        merge(targetProp, sourceProp, overwrite);\n      } else if (overwrite || !(key in target)) {\n        // 否则只处理overwrite为true，或者在目标对象中没有此属性的情况\n        // NOTE，在 target[key] 不存在的时候也是直接覆盖\n        target[key] = clone(source[key], true);\n      }\n    }\n  }\n\n  return target;\n}\n/**\n * @param {Array} targetAndSources The first item is target, and the rests are source.\n * @param {boolean} [overwrite=false]\n * @return {*} target\n */\n\n\nfunction mergeAll(targetAndSources, overwrite) {\n  var result = targetAndSources[0];\n\n  for (var i = 1, len = targetAndSources.length; i < len; i++) {\n    result = merge(result, targetAndSources[i], overwrite);\n  }\n\n  return result;\n}\n/**\n * @param {*} target\n * @param {*} source\n * @memberOf module:zrender/core/util\n */\n\n\nfunction extend(target, source) {\n  for (var key in source) {\n    if (source.hasOwnProperty(key)) {\n      target[key] = source[key];\n    }\n  }\n\n  return target;\n}\n/**\n * @param {*} target\n * @param {*} source\n * @param {boolean} [overlay=false]\n * @memberOf module:zrender/core/util\n */\n\n\nfunction defaults(target, source, overlay) {\n  for (var key in source) {\n    if (source.hasOwnProperty(key) && (overlay ? source[key] != null : target[key] == null)) {\n      target[key] = source[key];\n    }\n  }\n\n  return target;\n}\n\nvar createCanvas = function () {\n  return methods.createCanvas();\n};\n\nmethods.createCanvas = function () {\n  return document.createElement('canvas');\n}; // FIXME\n\n\nvar _ctx;\n\nfunction getContext() {\n  if (!_ctx) {\n    // Use util.createCanvas instead of createCanvas\n    // because createCanvas may be overwritten in different environment\n    _ctx = createCanvas().getContext('2d');\n  }\n\n  return _ctx;\n}\n/**\n * 查询数组中元素的index\n * @memberOf module:zrender/core/util\n */\n\n\nfunction indexOf(array, value) {\n  if (array) {\n    if (array.indexOf) {\n      return array.indexOf(value);\n    }\n\n    for (var i = 0, len = array.length; i < len; i++) {\n      if (array[i] === value) {\n        return i;\n      }\n    }\n  }\n\n  return -1;\n}\n/**\n * 构造类继承关系\n *\n * @memberOf module:zrender/core/util\n * @param {Function} clazz 源类\n * @param {Function} baseClazz 基类\n */\n\n\nfunction inherits(clazz, baseClazz) {\n  var clazzPrototype = clazz.prototype;\n\n  function F() {}\n\n  F.prototype = baseClazz.prototype;\n  clazz.prototype = new F();\n\n  for (var prop in clazzPrototype) {\n    clazz.prototype[prop] = clazzPrototype[prop];\n  }\n\n  clazz.prototype.constructor = clazz;\n  clazz.superClass = baseClazz;\n}\n/**\n * @memberOf module:zrender/core/util\n * @param {Object|Function} target\n * @param {Object|Function} sorce\n * @param {boolean} overlay\n */\n\n\nfunction mixin(target, source, overlay) {\n  target = 'prototype' in target ? target.prototype : target;\n  source = 'prototype' in source ? source.prototype : source;\n  defaults(target, source, overlay);\n}\n/**\n * Consider typed array.\n * @param {Array|TypedArray} data\n */\n\n\nfunction isArrayLike(data) {\n  if (!data) {\n    return;\n  }\n\n  if (typeof data === 'string') {\n    return false;\n  }\n\n  return typeof data.length === 'number';\n}\n/**\n * 数组或对象遍历\n * @memberOf module:zrender/core/util\n * @param {Object|Array} obj\n * @param {Function} cb\n * @param {*} [context]\n */\n\n\nfunction each(obj, cb, context) {\n  if (!(obj && cb)) {\n    return;\n  }\n\n  if (obj.forEach && obj.forEach === nativeForEach) {\n    obj.forEach(cb, context);\n  } else if (obj.length === +obj.length) {\n    for (var i = 0, len = obj.length; i < len; i++) {\n      cb.call(context, obj[i], i, obj);\n    }\n  } else {\n    for (var key in obj) {\n      if (obj.hasOwnProperty(key)) {\n        cb.call(context, obj[key], key, obj);\n      }\n    }\n  }\n}\n/**\n * 数组映射\n * @memberOf module:zrender/core/util\n * @param {Array} obj\n * @param {Function} cb\n * @param {*} [context]\n * @return {Array}\n */\n\n\nfunction map(obj, cb, context) {\n  if (!(obj && cb)) {\n    return;\n  }\n\n  if (obj.map && obj.map === nativeMap) {\n    return obj.map(cb, context);\n  } else {\n    var result = [];\n\n    for (var i = 0, len = obj.length; i < len; i++) {\n      result.push(cb.call(context, obj[i], i, obj));\n    }\n\n    return result;\n  }\n}\n/**\n * @memberOf module:zrender/core/util\n * @param {Array} obj\n * @param {Function} cb\n * @param {Object} [memo]\n * @param {*} [context]\n * @return {Array}\n */\n\n\nfunction reduce(obj, cb, memo, context) {\n  if (!(obj && cb)) {\n    return;\n  }\n\n  if (obj.reduce && obj.reduce === nativeReduce) {\n    return obj.reduce(cb, memo, context);\n  } else {\n    for (var i = 0, len = obj.length; i < len; i++) {\n      memo = cb.call(context, memo, obj[i], i, obj);\n    }\n\n    return memo;\n  }\n}\n/**\n * 数组过滤\n * @memberOf module:zrender/core/util\n * @param {Array} obj\n * @param {Function} cb\n * @param {*} [context]\n * @return {Array}\n */\n\n\nfunction filter(obj, cb, context) {\n  if (!(obj && cb)) {\n    return;\n  }\n\n  if (obj.filter && obj.filter === nativeFilter) {\n    return obj.filter(cb, context);\n  } else {\n    var result = [];\n\n    for (var i = 0, len = obj.length; i < len; i++) {\n      if (cb.call(context, obj[i], i, obj)) {\n        result.push(obj[i]);\n      }\n    }\n\n    return result;\n  }\n}\n/**\n * 数组项查找\n * @memberOf module:zrender/core/util\n * @param {Array} obj\n * @param {Function} cb\n * @param {*} [context]\n * @return {*}\n */\n\n\nfunction find(obj, cb, context) {\n  if (!(obj && cb)) {\n    return;\n  }\n\n  for (var i = 0, len = obj.length; i < len; i++) {\n    if (cb.call(context, obj[i], i, obj)) {\n      return obj[i];\n    }\n  }\n}\n/**\n * @memberOf module:zrender/core/util\n * @param {Function} func\n * @param {*} context\n * @return {Function}\n */\n\n\nfunction bind(func, context) {\n  var args = nativeSlice.call(arguments, 2);\n  return function () {\n    return func.apply(context, args.concat(nativeSlice.call(arguments)));\n  };\n}\n/**\n * @memberOf module:zrender/core/util\n * @param {Function} func\n * @return {Function}\n */\n\n\nfunction curry(func) {\n  var args = nativeSlice.call(arguments, 1);\n  return function () {\n    return func.apply(this, args.concat(nativeSlice.call(arguments)));\n  };\n}\n/**\n * @memberOf module:zrender/core/util\n * @param {*} value\n * @return {boolean}\n */\n\n\nfunction isArray(value) {\n  return objToString.call(value) === '[object Array]';\n}\n/**\n * @memberOf module:zrender/core/util\n * @param {*} value\n * @return {boolean}\n */\n\n\nfunction isFunction(value) {\n  return typeof value === 'function';\n}\n/**\n * @memberOf module:zrender/core/util\n * @param {*} value\n * @return {boolean}\n */\n\n\nfunction isString(value) {\n  return objToString.call(value) === '[object String]';\n}\n/**\n * @memberOf module:zrender/core/util\n * @param {*} value\n * @return {boolean}\n */\n\n\nfunction isObject(value) {\n  // Avoid a V8 JIT bug in Chrome 19-20.\n  // See https://code.google.com/p/v8/issues/detail?id=2291 for more details.\n  var type = typeof value;\n  return type === 'function' || !!value && type === 'object';\n}\n/**\n * @memberOf module:zrender/core/util\n * @param {*} value\n * @return {boolean}\n */\n\n\nfunction isBuiltInObject(value) {\n  return !!BUILTIN_OBJECT[objToString.call(value)];\n}\n/**\n * @memberOf module:zrender/core/util\n * @param {*} value\n * @return {boolean}\n */\n\n\nfunction isTypedArray(value) {\n  return !!TYPED_ARRAY[objToString.call(value)];\n}\n/**\n * @memberOf module:zrender/core/util\n * @param {*} value\n * @return {boolean}\n */\n\n\nfunction isDom(value) {\n  return typeof value === 'object' && typeof value.nodeType === 'number' && typeof value.ownerDocument === 'object';\n}\n/**\n * Whether is exactly NaN. Notice isNaN('a') returns true.\n * @param {*} value\n * @return {boolean}\n */\n\n\nfunction eqNaN(value) {\n  return value !== value;\n}\n/**\n * If value1 is not null, then return value1, otherwise judget rest of values.\n * Low performance.\n * @memberOf module:zrender/core/util\n * @return {*} Final value\n */\n\n\nfunction retrieve(values) {\n  for (var i = 0, len = arguments.length; i < len; i++) {\n    if (arguments[i] != null) {\n      return arguments[i];\n    }\n  }\n}\n\nfunction retrieve2(value0, value1) {\n  return value0 != null ? value0 : value1;\n}\n\nfunction retrieve3(value0, value1, value2) {\n  return value0 != null ? value0 : value1 != null ? value1 : value2;\n}\n/**\n * @memberOf module:zrender/core/util\n * @param {Array} arr\n * @param {number} startIndex\n * @param {number} endIndex\n * @return {Array}\n */\n\n\nfunction slice() {\n  return Function.call.apply(nativeSlice, arguments);\n}\n/**\n * Normalize css liked array configuration\n * e.g.\n *  3 => [3, 3, 3, 3]\n *  [4, 2] => [4, 2, 4, 2]\n *  [4, 3, 2] => [4, 3, 2, 3]\n * @param {number|Array.<number>} val\n * @return {Array.<number>}\n */\n\n\nfunction normalizeCssArray(val) {\n  if (typeof val === 'number') {\n    return [val, val, val, val];\n  }\n\n  var len = val.length;\n\n  if (len === 2) {\n    // vertical | horizontal\n    return [val[0], val[1], val[0], val[1]];\n  } else if (len === 3) {\n    // top | horizontal | bottom\n    return [val[0], val[1], val[2], val[1]];\n  }\n\n  return val;\n}\n/**\n * @memberOf module:zrender/core/util\n * @param {boolean} condition\n * @param {string} message\n */\n\n\nfunction assert(condition, message) {\n  if (!condition) {\n    throw new Error(message);\n  }\n}\n/**\n * @memberOf module:zrender/core/util\n * @param {string} str string to be trimed\n * @return {string} trimed string\n */\n\n\nfunction trim(str) {\n  if (str == null) {\n    return null;\n  } else if (typeof str.trim === 'function') {\n    return str.trim();\n  } else {\n    return str.replace(/^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g, '');\n  }\n}\n\nvar primitiveKey = '__ec_primitive__';\n/**\n * Set an object as primitive to be ignored traversing children in clone or merge\n */\n\nfunction setAsPrimitive(obj) {\n  obj[primitiveKey] = true;\n}\n\nfunction isPrimitive(obj) {\n  return obj[primitiveKey];\n}\n/**\n * @constructor\n * @param {Object} obj Only apply `ownProperty`.\n */\n\n\nfunction HashMap(obj) {\n  var isArr = isArray(obj); // Key should not be set on this, otherwise\n  // methods get/set/... may be overrided.\n\n  this.data = {};\n  var thisMap = this;\n  obj instanceof HashMap ? obj.each(visit) : obj && each(obj, visit);\n\n  function visit(value, key) {\n    isArr ? thisMap.set(value, key) : thisMap.set(key, value);\n  }\n}\n\nHashMap.prototype = {\n  constructor: HashMap,\n  // Do not provide `has` method to avoid defining what is `has`.\n  // (We usually treat `null` and `undefined` as the same, different\n  // from ES6 Map).\n  get: function (key) {\n    return this.data.hasOwnProperty(key) ? this.data[key] : null;\n  },\n  set: function (key, value) {\n    // Comparing with invocation chaining, `return value` is more commonly\n    // used in this case: `var someVal = map.set('a', genVal());`\n    return this.data[key] = value;\n  },\n  // Although util.each can be performed on this hashMap directly, user\n  // should not use the exposed keys, who are prefixed.\n  each: function (cb, context) {\n    context !== void 0 && (cb = bind(cb, context));\n\n    for (var key in this.data) {\n      this.data.hasOwnProperty(key) && cb(this.data[key], key);\n    }\n  },\n  // Do not use this method if performance sensitive.\n  removeKey: function (key) {\n    delete this.data[key];\n  }\n};\n\nfunction createHashMap(obj) {\n  return new HashMap(obj);\n}\n\nfunction concatArray(a, b) {\n  var newArray = new a.constructor(a.length + b.length);\n\n  for (var i = 0; i < a.length; i++) {\n    newArray[i] = a[i];\n  }\n\n  var offset = a.length;\n\n  for (i = 0; i < b.length; i++) {\n    newArray[i + offset] = b[i];\n  }\n\n  return newArray;\n}\n\nfunction noop() {}\n\nexports.$override = $override;\nexports.clone = clone;\nexports.merge = merge;\nexports.mergeAll = mergeAll;\nexports.extend = extend;\nexports.defaults = defaults;\nexports.createCanvas = createCanvas;\nexports.getContext = getContext;\nexports.indexOf = indexOf;\nexports.inherits = inherits;\nexports.mixin = mixin;\nexports.isArrayLike = isArrayLike;\nexports.each = each;\nexports.map = map;\nexports.reduce = reduce;\nexports.filter = filter;\nexports.find = find;\nexports.bind = bind;\nexports.curry = curry;\nexports.isArray = isArray;\nexports.isFunction = isFunction;\nexports.isString = isString;\nexports.isObject = isObject;\nexports.isBuiltInObject = isBuiltInObject;\nexports.isTypedArray = isTypedArray;\nexports.isDom = isDom;\nexports.eqNaN = eqNaN;\nexports.retrieve = retrieve;\nexports.retrieve2 = retrieve2;\nexports.retrieve3 = retrieve3;\nexports.slice = slice;\nexports.normalizeCssArray = normalizeCssArray;\nexports.assert = assert;\nexports.trim = trim;\nexports.setAsPrimitive = setAsPrimitive;\nexports.isPrimitive = isPrimitive;\nexports.createHashMap = createHashMap;\nexports.concatArray = concatArray;\nexports.noop = noop;","var Displayable = require(\"./Displayable\");\n\nvar zrUtil = require(\"../core/util\");\n\nvar PathProxy = require(\"../core/PathProxy\");\n\nvar pathContain = require(\"../contain/path\");\n\nvar Pattern = require(\"./Pattern\");\n\nvar getCanvasPattern = Pattern.prototype.getCanvasPattern;\nvar abs = Math.abs;\nvar pathProxyForDraw = new PathProxy(true);\n/**\n * @alias module:zrender/graphic/Path\n * @extends module:zrender/graphic/Displayable\n * @constructor\n * @param {Object} opts\n */\n\nfunction Path(opts) {\n  Displayable.call(this, opts);\n  /**\n   * @type {module:zrender/core/PathProxy}\n   * @readOnly\n   */\n\n  this.path = null;\n}\n\nPath.prototype = {\n  constructor: Path,\n  type: 'path',\n  __dirtyPath: true,\n  strokeContainThreshold: 5,\n\n  /**\n   * See `module:zrender/src/graphic/helper/subPixelOptimize`.\n   * @type {boolean}\n   */\n  subPixelOptimize: false,\n  brush: function (ctx, prevEl) {\n    var style = this.style;\n    var path = this.path || pathProxyForDraw;\n    var hasStroke = style.hasStroke();\n    var hasFill = style.hasFill();\n    var fill = style.fill;\n    var stroke = style.stroke;\n    var hasFillGradient = hasFill && !!fill.colorStops;\n    var hasStrokeGradient = hasStroke && !!stroke.colorStops;\n    var hasFillPattern = hasFill && !!fill.image;\n    var hasStrokePattern = hasStroke && !!stroke.image;\n    style.bind(ctx, this, prevEl);\n    this.setTransform(ctx);\n\n    if (this.__dirty) {\n      var rect; // Update gradient because bounding rect may changed\n\n      if (hasFillGradient) {\n        rect = rect || this.getBoundingRect();\n        this._fillGradient = style.getGradient(ctx, fill, rect);\n      }\n\n      if (hasStrokeGradient) {\n        rect = rect || this.getBoundingRect();\n        this._strokeGradient = style.getGradient(ctx, stroke, rect);\n      }\n    } // Use the gradient or pattern\n\n\n    if (hasFillGradient) {\n      // PENDING If may have affect the state\n      ctx.fillStyle = this._fillGradient;\n    } else if (hasFillPattern) {\n      ctx.fillStyle = getCanvasPattern.call(fill, ctx);\n    }\n\n    if (hasStrokeGradient) {\n      ctx.strokeStyle = this._strokeGradient;\n    } else if (hasStrokePattern) {\n      ctx.strokeStyle = getCanvasPattern.call(stroke, ctx);\n    }\n\n    var lineDash = style.lineDash;\n    var lineDashOffset = style.lineDashOffset;\n    var ctxLineDash = !!ctx.setLineDash; // Update path sx, sy\n\n    var scale = this.getGlobalScale();\n    path.setScale(scale[0], scale[1]); // Proxy context\n    // Rebuild path in following 2 cases\n    // 1. Path is dirty\n    // 2. Path needs javascript implemented lineDash stroking.\n    //    In this case, lineDash information will not be saved in PathProxy\n\n    if (this.__dirtyPath || lineDash && !ctxLineDash && hasStroke) {\n      path.beginPath(ctx); // Setting line dash before build path\n\n      if (lineDash && !ctxLineDash) {\n        path.setLineDash(lineDash);\n        path.setLineDashOffset(lineDashOffset);\n      }\n\n      this.buildPath(path, this.shape, false); // Clear path dirty flag\n\n      if (this.path) {\n        this.__dirtyPath = false;\n      }\n    } else {\n      // Replay path building\n      ctx.beginPath();\n      this.path.rebuildPath(ctx);\n    }\n\n    if (hasFill) {\n      if (style.fillOpacity != null) {\n        var originalGlobalAlpha = ctx.globalAlpha;\n        ctx.globalAlpha = style.fillOpacity * style.opacity;\n        path.fill(ctx);\n        ctx.globalAlpha = originalGlobalAlpha;\n      } else {\n        path.fill(ctx);\n      }\n    }\n\n    if (lineDash && ctxLineDash) {\n      ctx.setLineDash(lineDash);\n      ctx.lineDashOffset = lineDashOffset;\n    }\n\n    if (hasStroke) {\n      if (style.strokeOpacity != null) {\n        var originalGlobalAlpha = ctx.globalAlpha;\n        ctx.globalAlpha = style.strokeOpacity * style.opacity;\n        path.stroke(ctx);\n        ctx.globalAlpha = originalGlobalAlpha;\n      } else {\n        path.stroke(ctx);\n      }\n    }\n\n    if (lineDash && ctxLineDash) {\n      // PENDING\n      // Remove lineDash\n      ctx.setLineDash([]);\n    } // Draw rect text\n\n\n    if (style.text != null) {\n      // Only restore transform when needs draw text.\n      this.restoreTransform(ctx);\n      this.drawRectText(ctx, this.getBoundingRect());\n    }\n  },\n  // When bundling path, some shape may decide if use moveTo to begin a new subpath or closePath\n  // Like in circle\n  buildPath: function (ctx, shapeCfg, inBundle) {},\n  createPathProxy: function () {\n    this.path = new PathProxy();\n  },\n  getBoundingRect: function () {\n    var rect = this._rect;\n    var style = this.style;\n    var needsUpdateRect = !rect;\n\n    if (needsUpdateRect) {\n      var path = this.path;\n\n      if (!path) {\n        // Create path on demand.\n        path = this.path = new PathProxy();\n      }\n\n      if (this.__dirtyPath) {\n        path.beginPath();\n        this.buildPath(path, this.shape, false);\n      }\n\n      rect = path.getBoundingRect();\n    }\n\n    this._rect = rect;\n\n    if (style.hasStroke()) {\n      // Needs update rect with stroke lineWidth when\n      // 1. Element changes scale or lineWidth\n      // 2. Shape is changed\n      var rectWithStroke = this._rectWithStroke || (this._rectWithStroke = rect.clone());\n\n      if (this.__dirty || needsUpdateRect) {\n        rectWithStroke.copy(rect); // FIXME Must after updateTransform\n\n        var w = style.lineWidth; // PENDING, Min line width is needed when line is horizontal or vertical\n\n        var lineScale = style.strokeNoScale ? this.getLineScale() : 1; // Only add extra hover lineWidth when there are no fill\n\n        if (!style.hasFill()) {\n          w = Math.max(w, this.strokeContainThreshold || 4);\n        } // Consider line width\n        // Line scale can't be 0;\n\n\n        if (lineScale > 1e-10) {\n          rectWithStroke.width += w / lineScale;\n          rectWithStroke.height += w / lineScale;\n          rectWithStroke.x -= w / lineScale / 2;\n          rectWithStroke.y -= w / lineScale / 2;\n        }\n      } // Return rect with stroke\n\n\n      return rectWithStroke;\n    }\n\n    return rect;\n  },\n  contain: function (x, y) {\n    var localPos = this.transformCoordToLocal(x, y);\n    var rect = this.getBoundingRect();\n    var style = this.style;\n    x = localPos[0];\n    y = localPos[1];\n\n    if (rect.contain(x, y)) {\n      var pathData = this.path.data;\n\n      if (style.hasStroke()) {\n        var lineWidth = style.lineWidth;\n        var lineScale = style.strokeNoScale ? this.getLineScale() : 1; // Line scale can't be 0;\n\n        if (lineScale > 1e-10) {\n          // Only add extra hover lineWidth when there are no fill\n          if (!style.hasFill()) {\n            lineWidth = Math.max(lineWidth, this.strokeContainThreshold);\n          }\n\n          if (pathContain.containStroke(pathData, lineWidth / lineScale, x, y)) {\n            return true;\n          }\n        }\n      }\n\n      if (style.hasFill()) {\n        return pathContain.contain(pathData, x, y);\n      }\n    }\n\n    return false;\n  },\n\n  /**\n   * @param  {boolean} dirtyPath\n   */\n  dirty: function (dirtyPath) {\n    if (dirtyPath == null) {\n      dirtyPath = true;\n    } // Only mark dirty, not mark clean\n\n\n    if (dirtyPath) {\n      this.__dirtyPath = dirtyPath;\n      this._rect = null;\n    }\n\n    this.__dirty = this.__dirtyText = true;\n    this.__zr && this.__zr.refresh(); // Used as a clipping path\n\n    if (this.__clipTarget) {\n      this.__clipTarget.dirty();\n    }\n  },\n\n  /**\n   * Alias for animate('shape')\n   * @param {boolean} loop\n   */\n  animateShape: function (loop) {\n    return this.animate('shape', loop);\n  },\n  // Overwrite attrKV\n  attrKV: function (key, value) {\n    // FIXME\n    if (key === 'shape') {\n      this.setShape(value);\n      this.__dirtyPath = true;\n      this._rect = null;\n    } else {\n      Displayable.prototype.attrKV.call(this, key, value);\n    }\n  },\n\n  /**\n   * @param {Object|string} key\n   * @param {*} value\n   */\n  setShape: function (key, value) {\n    var shape = this.shape; // Path from string may not have shape\n\n    if (shape) {\n      if (zrUtil.isObject(key)) {\n        for (var name in key) {\n          if (key.hasOwnProperty(name)) {\n            shape[name] = key[name];\n          }\n        }\n      } else {\n        shape[key] = value;\n      }\n\n      this.dirty(true);\n    }\n\n    return this;\n  },\n  getLineScale: function () {\n    var m = this.transform; // Get the line scale.\n    // Determinant of `m` means how much the area is enlarged by the\n    // transformation. So its square root can be used as a scale factor\n    // for width.\n\n    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;\n  }\n};\n/**\n * 扩展一个 Path element, 比如星形，圆等。\n * Extend a path element\n * @param {Object} props\n * @param {string} props.type Path type\n * @param {Function} props.init Initialize\n * @param {Function} props.buildPath Overwrite buildPath method\n * @param {Object} [props.style] Extended default style config\n * @param {Object} [props.shape] Extended default shape config\n */\n\nPath.extend = function (defaults) {\n  var Sub = function (opts) {\n    Path.call(this, opts);\n\n    if (defaults.style) {\n      // Extend default style\n      this.style.extendFrom(defaults.style, false);\n    } // Extend default shape\n\n\n    var defaultShape = defaults.shape;\n\n    if (defaultShape) {\n      this.shape = this.shape || {};\n      var thisShape = this.shape;\n\n      for (var name in defaultShape) {\n        if (!thisShape.hasOwnProperty(name) && defaultShape.hasOwnProperty(name)) {\n          thisShape[name] = defaultShape[name];\n        }\n      }\n    }\n\n    defaults.init && defaults.init.call(this, opts);\n  };\n\n  zrUtil.inherits(Sub, Path); // FIXME 不能 extend position, rotation 等引用对象\n\n  for (var name in defaults) {\n    // Extending prototype values and methods\n    if (name !== 'style' && name !== 'shape') {\n      Sub.prototype[name] = defaults[name];\n    }\n  }\n\n  return Sub;\n};\n\nzrUtil.inherits(Path, Displayable);\nvar _default = Path;\nmodule.exports = _default;","var ArrayCtor = typeof Float32Array === 'undefined' ? Array : Float32Array;\n/**\n * 创建一个向量\n * @param {number} [x=0]\n * @param {number} [y=0]\n * @return {Vector2}\n */\n\nfunction create(x, y) {\n  var out = new ArrayCtor(2);\n\n  if (x == null) {\n    x = 0;\n  }\n\n  if (y == null) {\n    y = 0;\n  }\n\n  out[0] = x;\n  out[1] = y;\n  return out;\n}\n/**\n * 复制向量数据\n * @param {Vector2} out\n * @param {Vector2} v\n * @return {Vector2}\n */\n\n\nfunction copy(out, v) {\n  out[0] = v[0];\n  out[1] = v[1];\n  return out;\n}\n/**\n * 克隆一个向量\n * @param {Vector2} v\n * @return {Vector2}\n */\n\n\nfunction clone(v) {\n  var out = new ArrayCtor(2);\n  out[0] = v[0];\n  out[1] = v[1];\n  return out;\n}\n/**\n * 设置向量的两个项\n * @param {Vector2} out\n * @param {number} a\n * @param {number} b\n * @return {Vector2} 结果\n */\n\n\nfunction set(out, a, b) {\n  out[0] = a;\n  out[1] = b;\n  return out;\n}\n/**\n * 向量相加\n * @param {Vector2} out\n * @param {Vector2} v1\n * @param {Vector2} v2\n */\n\n\nfunction add(out, v1, v2) {\n  out[0] = v1[0] + v2[0];\n  out[1] = v1[1] + v2[1];\n  return out;\n}\n/**\n * 向量缩放后相加\n * @param {Vector2} out\n * @param {Vector2} v1\n * @param {Vector2} v2\n * @param {number} a\n */\n\n\nfunction scaleAndAdd(out, v1, v2, a) {\n  out[0] = v1[0] + v2[0] * a;\n  out[1] = v1[1] + v2[1] * a;\n  return out;\n}\n/**\n * 向量相减\n * @param {Vector2} out\n * @param {Vector2} v1\n * @param {Vector2} v2\n */\n\n\nfunction sub(out, v1, v2) {\n  out[0] = v1[0] - v2[0];\n  out[1] = v1[1] - v2[1];\n  return out;\n}\n/**\n * 向量长度\n * @param {Vector2} v\n * @return {number}\n */\n\n\nfunction len(v) {\n  return Math.sqrt(lenSquare(v));\n}\n\nvar length = len; // jshint ignore:line\n\n/**\n * 向量长度平方\n * @param {Vector2} v\n * @return {number}\n */\n\nfunction lenSquare(v) {\n  return v[0] * v[0] + v[1] * v[1];\n}\n\nvar lengthSquare = lenSquare;\n/**\n * 向量乘法\n * @param {Vector2} out\n * @param {Vector2} v1\n * @param {Vector2} v2\n */\n\nfunction mul(out, v1, v2) {\n  out[0] = v1[0] * v2[0];\n  out[1] = v1[1] * v2[1];\n  return out;\n}\n/**\n * 向量除法\n * @param {Vector2} out\n * @param {Vector2} v1\n * @param {Vector2} v2\n */\n\n\nfunction div(out, v1, v2) {\n  out[0] = v1[0] / v2[0];\n  out[1] = v1[1] / v2[1];\n  return out;\n}\n/**\n * 向量点乘\n * @param {Vector2} v1\n * @param {Vector2} v2\n * @return {number}\n */\n\n\nfunction dot(v1, v2) {\n  return v1[0] * v2[0] + v1[1] * v2[1];\n}\n/**\n * 向量缩放\n * @param {Vector2} out\n * @param {Vector2} v\n * @param {number} s\n */\n\n\nfunction scale(out, v, s) {\n  out[0] = v[0] * s;\n  out[1] = v[1] * s;\n  return out;\n}\n/**\n * 向量归一化\n * @param {Vector2} out\n * @param {Vector2} v\n */\n\n\nfunction normalize(out, v) {\n  var d = len(v);\n\n  if (d === 0) {\n    out[0] = 0;\n    out[1] = 0;\n  } else {\n    out[0] = v[0] / d;\n    out[1] = v[1] / d;\n  }\n\n  return out;\n}\n/**\n * 计算向量间距离\n * @param {Vector2} v1\n * @param {Vector2} v2\n * @return {number}\n */\n\n\nfunction distance(v1, v2) {\n  return Math.sqrt((v1[0] - v2[0]) * (v1[0] - v2[0]) + (v1[1] - v2[1]) * (v1[1] - v2[1]));\n}\n\nvar dist = distance;\n/**\n * 向量距离平方\n * @param {Vector2} v1\n * @param {Vector2} v2\n * @return {number}\n */\n\nfunction distanceSquare(v1, v2) {\n  return (v1[0] - v2[0]) * (v1[0] - v2[0]) + (v1[1] - v2[1]) * (v1[1] - v2[1]);\n}\n\nvar distSquare = distanceSquare;\n/**\n * 求负向量\n * @param {Vector2} out\n * @param {Vector2} v\n */\n\nfunction negate(out, v) {\n  out[0] = -v[0];\n  out[1] = -v[1];\n  return out;\n}\n/**\n * 插值两个点\n * @param {Vector2} out\n * @param {Vector2} v1\n * @param {Vector2} v2\n * @param {number} t\n */\n\n\nfunction lerp(out, v1, v2, t) {\n  out[0] = v1[0] + t * (v2[0] - v1[0]);\n  out[1] = v1[1] + t * (v2[1] - v1[1]);\n  return out;\n}\n/**\n * 矩阵左乘向量\n * @param {Vector2} out\n * @param {Vector2} v\n * @param {Vector2} m\n */\n\n\nfunction applyTransform(out, v, m) {\n  var x = v[0];\n  var y = v[1];\n  out[0] = m[0] * x + m[2] * y + m[4];\n  out[1] = m[1] * x + m[3] * y + m[5];\n  return out;\n}\n/**\n * 求两个向量最小值\n * @param  {Vector2} out\n * @param  {Vector2} v1\n * @param  {Vector2} v2\n */\n\n\nfunction min(out, v1, v2) {\n  out[0] = Math.min(v1[0], v2[0]);\n  out[1] = Math.min(v1[1], v2[1]);\n  return out;\n}\n/**\n * 求两个向量最大值\n * @param  {Vector2} out\n * @param  {Vector2} v1\n * @param  {Vector2} v2\n */\n\n\nfunction max(out, v1, v2) {\n  out[0] = Math.max(v1[0], v2[0]);\n  out[1] = Math.max(v1[1], v2[1]);\n  return out;\n}\n\nexports.create = create;\nexports.copy = copy;\nexports.clone = clone;\nexports.set = set;\nexports.add = add;\nexports.scaleAndAdd = scaleAndAdd;\nexports.sub = sub;\nexports.len = len;\nexports.length = length;\nexports.lenSquare = lenSquare;\nexports.lengthSquare = lengthSquare;\nexports.mul = mul;\nexports.div = div;\nexports.dot = dot;\nexports.scale = scale;\nexports.normalize = normalize;\nexports.distance = distance;\nexports.dist = dist;\nexports.distanceSquare = distanceSquare;\nexports.distSquare = distSquare;\nexports.negate = negate;\nexports.lerp = lerp;\nexports.applyTransform = applyTransform;\nexports.min = min;\nexports.max = max;","var vec2 = require(\"./vector\");\n\nvar matrix = require(\"./matrix\");\n\n/**\n * @module echarts/core/BoundingRect\n */\nvar v2ApplyTransform = vec2.applyTransform;\nvar mathMin = Math.min;\nvar mathMax = Math.max;\n/**\n * @alias module:echarts/core/BoundingRect\n */\n\nfunction BoundingRect(x, y, width, height) {\n  if (width < 0) {\n    x = x + width;\n    width = -width;\n  }\n\n  if (height < 0) {\n    y = y + height;\n    height = -height;\n  }\n  /**\n   * @type {number}\n   */\n\n\n  this.x = x;\n  /**\n   * @type {number}\n   */\n\n  this.y = y;\n  /**\n   * @type {number}\n   */\n\n  this.width = width;\n  /**\n   * @type {number}\n   */\n\n  this.height = height;\n}\n\nBoundingRect.prototype = {\n  constructor: BoundingRect,\n\n  /**\n   * @param {module:echarts/core/BoundingRect} other\n   */\n  union: function (other) {\n    var x = mathMin(other.x, this.x);\n    var y = mathMin(other.y, this.y);\n    this.width = mathMax(other.x + other.width, this.x + this.width) - x;\n    this.height = mathMax(other.y + other.height, this.y + this.height) - y;\n    this.x = x;\n    this.y = y;\n  },\n\n  /**\n   * @param {Array.<number>} m\n   * @methods\n   */\n  applyTransform: function () {\n    var lt = [];\n    var rb = [];\n    var lb = [];\n    var rt = [];\n    return function (m) {\n      // In case usage like this\n      // el.getBoundingRect().applyTransform(el.transform)\n      // And element has no transform\n      if (!m) {\n        return;\n      }\n\n      lt[0] = lb[0] = this.x;\n      lt[1] = rt[1] = this.y;\n      rb[0] = rt[0] = this.x + this.width;\n      rb[1] = lb[1] = this.y + this.height;\n      v2ApplyTransform(lt, lt, m);\n      v2ApplyTransform(rb, rb, m);\n      v2ApplyTransform(lb, lb, m);\n      v2ApplyTransform(rt, rt, m);\n      this.x = mathMin(lt[0], rb[0], lb[0], rt[0]);\n      this.y = mathMin(lt[1], rb[1], lb[1], rt[1]);\n      var maxX = mathMax(lt[0], rb[0], lb[0], rt[0]);\n      var maxY = mathMax(lt[1], rb[1], lb[1], rt[1]);\n      this.width = maxX - this.x;\n      this.height = maxY - this.y;\n    };\n  }(),\n\n  /**\n   * Calculate matrix of transforming from self to target rect\n   * @param  {module:zrender/core/BoundingRect} b\n   * @return {Array.<number>}\n   */\n  calculateTransform: function (b) {\n    var a = this;\n    var sx = b.width / a.width;\n    var sy = b.height / a.height;\n    var m = matrix.create(); // 矩阵右乘\n\n    matrix.translate(m, m, [-a.x, -a.y]);\n    matrix.scale(m, m, [sx, sy]);\n    matrix.translate(m, m, [b.x, b.y]);\n    return m;\n  },\n\n  /**\n   * @param {(module:echarts/core/BoundingRect|Object)} b\n   * @return {boolean}\n   */\n  intersect: function (b) {\n    if (!b) {\n      return false;\n    }\n\n    if (!(b instanceof BoundingRect)) {\n      // Normalize negative width/height.\n      b = BoundingRect.create(b);\n    }\n\n    var a = this;\n    var ax0 = a.x;\n    var ax1 = a.x + a.width;\n    var ay0 = a.y;\n    var ay1 = a.y + a.height;\n    var bx0 = b.x;\n    var bx1 = b.x + b.width;\n    var by0 = b.y;\n    var by1 = b.y + b.height;\n    return !(ax1 < bx0 || bx1 < ax0 || ay1 < by0 || by1 < ay0);\n  },\n  contain: function (x, y) {\n    var rect = this;\n    return x >= rect.x && x <= rect.x + rect.width && y >= rect.y && y <= rect.y + rect.height;\n  },\n\n  /**\n   * @return {module:echarts/core/BoundingRect}\n   */\n  clone: function () {\n    return new BoundingRect(this.x, this.y, this.width, this.height);\n  },\n\n  /**\n   * Copy from another rect\n   */\n  copy: function (other) {\n    this.x = other.x;\n    this.y = other.y;\n    this.width = other.width;\n    this.height = other.height;\n  },\n  plain: function () {\n    return {\n      x: this.x,\n      y: this.y,\n      width: this.width,\n      height: this.height\n    };\n  }\n};\n/**\n * @param {Object|module:zrender/core/BoundingRect} rect\n * @param {number} rect.x\n * @param {number} rect.y\n * @param {number} rect.width\n * @param {number} rect.height\n * @return {module:zrender/core/BoundingRect}\n */\n\nBoundingRect.create = function (rect) {\n  return new BoundingRect(rect.x, rect.y, rect.width, rect.height);\n};\n\nvar _default = BoundingRect;\nmodule.exports = _default;","var _vector = require(\"./vector\");\n\nvar v2Create = _vector.create;\nvar v2DistSquare = _vector.distSquare;\n\n/**\n * 曲线辅助模块\n * @module zrender/core/curve\n * @author pissang(https://www.github.com/pissang)\n */\nvar mathPow = Math.pow;\nvar mathSqrt = Math.sqrt;\nvar EPSILON = 1e-8;\nvar EPSILON_NUMERIC = 1e-4;\nvar THREE_SQRT = mathSqrt(3);\nvar ONE_THIRD = 1 / 3; // 临时变量\n\nvar _v0 = v2Create();\n\nvar _v1 = v2Create();\n\nvar _v2 = v2Create();\n\nfunction isAroundZero(val) {\n  return val > -EPSILON && val < EPSILON;\n}\n\nfunction isNotAroundZero(val) {\n  return val > EPSILON || val < -EPSILON;\n}\n/**\n * 计算三次贝塞尔值\n * @memberOf module:zrender/core/curve\n * @param  {number} p0\n * @param  {number} p1\n * @param  {number} p2\n * @param  {number} p3\n * @param  {number} t\n * @return {number}\n */\n\n\nfunction cubicAt(p0, p1, p2, p3, t) {\n  var onet = 1 - t;\n  return onet * onet * (onet * p0 + 3 * t * p1) + t * t * (t * p3 + 3 * onet * p2);\n}\n/**\n * 计算三次贝塞尔导数值\n * @memberOf module:zrender/core/curve\n * @param  {number} p0\n * @param  {number} p1\n * @param  {number} p2\n * @param  {number} p3\n * @param  {number} t\n * @return {number}\n */\n\n\nfunction cubicDerivativeAt(p0, p1, p2, p3, t) {\n  var onet = 1 - t;\n  return 3 * (((p1 - p0) * onet + 2 * (p2 - p1) * t) * onet + (p3 - p2) * t * t);\n}\n/**\n * 计算三次贝塞尔方程根，使用盛金公式\n * @memberOf module:zrender/core/curve\n * @param  {number} p0\n * @param  {number} p1\n * @param  {number} p2\n * @param  {number} p3\n * @param  {number} val\n * @param  {Array.<number>} roots\n * @return {number} 有效根数目\n */\n\n\nfunction cubicRootAt(p0, p1, p2, p3, val, roots) {\n  // Evaluate roots of cubic functions\n  var a = p3 + 3 * (p1 - p2) - p0;\n  var b = 3 * (p2 - p1 * 2 + p0);\n  var c = 3 * (p1 - p0);\n  var d = p0 - val;\n  var A = b * b - 3 * a * c;\n  var B = b * c - 9 * a * d;\n  var C = c * c - 3 * b * d;\n  var n = 0;\n\n  if (isAroundZero(A) && isAroundZero(B)) {\n    if (isAroundZero(b)) {\n      roots[0] = 0;\n    } else {\n      var t1 = -c / b; //t1, t2, t3, b is not zero\n\n      if (t1 >= 0 && t1 <= 1) {\n        roots[n++] = t1;\n      }\n    }\n  } else {\n    var disc = B * B - 4 * A * C;\n\n    if (isAroundZero(disc)) {\n      var K = B / A;\n      var t1 = -b / a + K; // t1, a is not zero\n\n      var t2 = -K / 2; // t2, t3\n\n      if (t1 >= 0 && t1 <= 1) {\n        roots[n++] = t1;\n      }\n\n      if (t2 >= 0 && t2 <= 1) {\n        roots[n++] = t2;\n      }\n    } else if (disc > 0) {\n      var discSqrt = mathSqrt(disc);\n      var Y1 = A * b + 1.5 * a * (-B + discSqrt);\n      var Y2 = A * b + 1.5 * a * (-B - discSqrt);\n\n      if (Y1 < 0) {\n        Y1 = -mathPow(-Y1, ONE_THIRD);\n      } else {\n        Y1 = mathPow(Y1, ONE_THIRD);\n      }\n\n      if (Y2 < 0) {\n        Y2 = -mathPow(-Y2, ONE_THIRD);\n      } else {\n        Y2 = mathPow(Y2, ONE_THIRD);\n      }\n\n      var t1 = (-b - (Y1 + Y2)) / (3 * a);\n\n      if (t1 >= 0 && t1 <= 1) {\n        roots[n++] = t1;\n      }\n    } else {\n      var T = (2 * A * b - 3 * a * B) / (2 * mathSqrt(A * A * A));\n      var theta = Math.acos(T) / 3;\n      var ASqrt = mathSqrt(A);\n      var tmp = Math.cos(theta);\n      var t1 = (-b - 2 * ASqrt * tmp) / (3 * a);\n      var t2 = (-b + ASqrt * (tmp + THREE_SQRT * Math.sin(theta))) / (3 * a);\n      var t3 = (-b + ASqrt * (tmp - THREE_SQRT * Math.sin(theta))) / (3 * a);\n\n      if (t1 >= 0 && t1 <= 1) {\n        roots[n++] = t1;\n      }\n\n      if (t2 >= 0 && t2 <= 1) {\n        roots[n++] = t2;\n      }\n\n      if (t3 >= 0 && t3 <= 1) {\n        roots[n++] = t3;\n      }\n    }\n  }\n\n  return n;\n}\n/**\n * 计算三次贝塞尔方程极限值的位置\n * @memberOf module:zrender/core/curve\n * @param  {number} p0\n * @param  {number} p1\n * @param  {number} p2\n * @param  {number} p3\n * @param  {Array.<number>} extrema\n * @return {number} 有效数目\n */\n\n\nfunction cubicExtrema(p0, p1, p2, p3, extrema) {\n  var b = 6 * p2 - 12 * p1 + 6 * p0;\n  var a = 9 * p1 + 3 * p3 - 3 * p0 - 9 * p2;\n  var c = 3 * p1 - 3 * p0;\n  var n = 0;\n\n  if (isAroundZero(a)) {\n    if (isNotAroundZero(b)) {\n      var t1 = -c / b;\n\n      if (t1 >= 0 && t1 <= 1) {\n        extrema[n++] = t1;\n      }\n    }\n  } else {\n    var disc = b * b - 4 * a * c;\n\n    if (isAroundZero(disc)) {\n      extrema[0] = -b / (2 * a);\n    } else if (disc > 0) {\n      var discSqrt = mathSqrt(disc);\n      var t1 = (-b + discSqrt) / (2 * a);\n      var t2 = (-b - discSqrt) / (2 * a);\n\n      if (t1 >= 0 && t1 <= 1) {\n        extrema[n++] = t1;\n      }\n\n      if (t2 >= 0 && t2 <= 1) {\n        extrema[n++] = t2;\n      }\n    }\n  }\n\n  return n;\n}\n/**\n * 细分三次贝塞尔曲线\n * @memberOf module:zrender/core/curve\n * @param  {number} p0\n * @param  {number} p1\n * @param  {number} p2\n * @param  {number} p3\n * @param  {number} t\n * @param  {Array.<number>} out\n */\n\n\nfunction cubicSubdivide(p0, p1, p2, p3, t, out) {\n  var p01 = (p1 - p0) * t + p0;\n  var p12 = (p2 - p1) * t + p1;\n  var p23 = (p3 - p2) * t + p2;\n  var p012 = (p12 - p01) * t + p01;\n  var p123 = (p23 - p12) * t + p12;\n  var p0123 = (p123 - p012) * t + p012; // Seg0\n\n  out[0] = p0;\n  out[1] = p01;\n  out[2] = p012;\n  out[3] = p0123; // Seg1\n\n  out[4] = p0123;\n  out[5] = p123;\n  out[6] = p23;\n  out[7] = p3;\n}\n/**\n * 投射点到三次贝塞尔曲线上，返回投射距离。\n * 投射点有可能会有一个或者多个，这里只返回其中距离最短的一个。\n * @param {number} x0\n * @param {number} y0\n * @param {number} x1\n * @param {number} y1\n * @param {number} x2\n * @param {number} y2\n * @param {number} x3\n * @param {number} y3\n * @param {number} x\n * @param {number} y\n * @param {Array.<number>} [out] 投射点\n * @return {number}\n */\n\n\nfunction cubicProjectPoint(x0, y0, x1, y1, x2, y2, x3, y3, x, y, out) {\n  // http://pomax.github.io/bezierinfo/#projections\n  var t;\n  var interval = 0.005;\n  var d = Infinity;\n  var prev;\n  var next;\n  var d1;\n  var d2;\n  _v0[0] = x;\n  _v0[1] = y; // 先粗略估计一下可能的最小距离的 t 值\n  // PENDING\n\n  for (var _t = 0; _t < 1; _t += 0.05) {\n    _v1[0] = cubicAt(x0, x1, x2, x3, _t);\n    _v1[1] = cubicAt(y0, y1, y2, y3, _t);\n    d1 = v2DistSquare(_v0, _v1);\n\n    if (d1 < d) {\n      t = _t;\n      d = d1;\n    }\n  }\n\n  d = Infinity; // At most 32 iteration\n\n  for (var i = 0; i < 32; i++) {\n    if (interval < EPSILON_NUMERIC) {\n      break;\n    }\n\n    prev = t - interval;\n    next = t + interval; // t - interval\n\n    _v1[0] = cubicAt(x0, x1, x2, x3, prev);\n    _v1[1] = cubicAt(y0, y1, y2, y3, prev);\n    d1 = v2DistSquare(_v1, _v0);\n\n    if (prev >= 0 && d1 < d) {\n      t = prev;\n      d = d1;\n    } else {\n      // t + interval\n      _v2[0] = cubicAt(x0, x1, x2, x3, next);\n      _v2[1] = cubicAt(y0, y1, y2, y3, next);\n      d2 = v2DistSquare(_v2, _v0);\n\n      if (next <= 1 && d2 < d) {\n        t = next;\n        d = d2;\n      } else {\n        interval *= 0.5;\n      }\n    }\n  } // t\n\n\n  if (out) {\n    out[0] = cubicAt(x0, x1, x2, x3, t);\n    out[1] = cubicAt(y0, y1, y2, y3, t);\n  } // console.log(interval, i);\n\n\n  return mathSqrt(d);\n}\n/**\n * 计算二次方贝塞尔值\n * @param  {number} p0\n * @param  {number} p1\n * @param  {number} p2\n * @param  {number} t\n * @return {number}\n */\n\n\nfunction quadraticAt(p0, p1, p2, t) {\n  var onet = 1 - t;\n  return onet * (onet * p0 + 2 * t * p1) + t * t * p2;\n}\n/**\n * 计算二次方贝塞尔导数值\n * @param  {number} p0\n * @param  {number} p1\n * @param  {number} p2\n * @param  {number} t\n * @return {number}\n */\n\n\nfunction quadraticDerivativeAt(p0, p1, p2, t) {\n  return 2 * ((1 - t) * (p1 - p0) + t * (p2 - p1));\n}\n/**\n * 计算二次方贝塞尔方程根\n * @param  {number} p0\n * @param  {number} p1\n * @param  {number} p2\n * @param  {number} t\n * @param  {Array.<number>} roots\n * @return {number} 有效根数目\n */\n\n\nfunction quadraticRootAt(p0, p1, p2, val, roots) {\n  var a = p0 - 2 * p1 + p2;\n  var b = 2 * (p1 - p0);\n  var c = p0 - val;\n  var n = 0;\n\n  if (isAroundZero(a)) {\n    if (isNotAroundZero(b)) {\n      var t1 = -c / b;\n\n      if (t1 >= 0 && t1 <= 1) {\n        roots[n++] = t1;\n      }\n    }\n  } else {\n    var disc = b * b - 4 * a * c;\n\n    if (isAroundZero(disc)) {\n      var t1 = -b / (2 * a);\n\n      if (t1 >= 0 && t1 <= 1) {\n        roots[n++] = t1;\n      }\n    } else if (disc > 0) {\n      var discSqrt = mathSqrt(disc);\n      var t1 = (-b + discSqrt) / (2 * a);\n      var t2 = (-b - discSqrt) / (2 * a);\n\n      if (t1 >= 0 && t1 <= 1) {\n        roots[n++] = t1;\n      }\n\n      if (t2 >= 0 && t2 <= 1) {\n        roots[n++] = t2;\n      }\n    }\n  }\n\n  return n;\n}\n/**\n * 计算二次贝塞尔方程极限值\n * @memberOf module:zrender/core/curve\n * @param  {number} p0\n * @param  {number} p1\n * @param  {number} p2\n * @return {number}\n */\n\n\nfunction quadraticExtremum(p0, p1, p2) {\n  var divider = p0 + p2 - 2 * p1;\n\n  if (divider === 0) {\n    // p1 is center of p0 and p2\n    return 0.5;\n  } else {\n    return (p0 - p1) / divider;\n  }\n}\n/**\n * 细分二次贝塞尔曲线\n * @memberOf module:zrender/core/curve\n * @param  {number} p0\n * @param  {number} p1\n * @param  {number} p2\n * @param  {number} t\n * @param  {Array.<number>} out\n */\n\n\nfunction quadraticSubdivide(p0, p1, p2, t, out) {\n  var p01 = (p1 - p0) * t + p0;\n  var p12 = (p2 - p1) * t + p1;\n  var p012 = (p12 - p01) * t + p01; // Seg0\n\n  out[0] = p0;\n  out[1] = p01;\n  out[2] = p012; // Seg1\n\n  out[3] = p012;\n  out[4] = p12;\n  out[5] = p2;\n}\n/**\n * 投射点到二次贝塞尔曲线上，返回投射距离。\n * 投射点有可能会有一个或者多个，这里只返回其中距离最短的一个。\n * @param {number} x0\n * @param {number} y0\n * @param {number} x1\n * @param {number} y1\n * @param {number} x2\n * @param {number} y2\n * @param {number} x\n * @param {number} y\n * @param {Array.<number>} out 投射点\n * @return {number}\n */\n\n\nfunction quadraticProjectPoint(x0, y0, x1, y1, x2, y2, x, y, out) {\n  // http://pomax.github.io/bezierinfo/#projections\n  var t;\n  var interval = 0.005;\n  var d = Infinity;\n  _v0[0] = x;\n  _v0[1] = y; // 先粗略估计一下可能的最小距离的 t 值\n  // PENDING\n\n  for (var _t = 0; _t < 1; _t += 0.05) {\n    _v1[0] = quadraticAt(x0, x1, x2, _t);\n    _v1[1] = quadraticAt(y0, y1, y2, _t);\n    var d1 = v2DistSquare(_v0, _v1);\n\n    if (d1 < d) {\n      t = _t;\n      d = d1;\n    }\n  }\n\n  d = Infinity; // At most 32 iteration\n\n  for (var i = 0; i < 32; i++) {\n    if (interval < EPSILON_NUMERIC) {\n      break;\n    }\n\n    var prev = t - interval;\n    var next = t + interval; // t - interval\n\n    _v1[0] = quadraticAt(x0, x1, x2, prev);\n    _v1[1] = quadraticAt(y0, y1, y2, prev);\n    var d1 = v2DistSquare(_v1, _v0);\n\n    if (prev >= 0 && d1 < d) {\n      t = prev;\n      d = d1;\n    } else {\n      // t + interval\n      _v2[0] = quadraticAt(x0, x1, x2, next);\n      _v2[1] = quadraticAt(y0, y1, y2, next);\n      var d2 = v2DistSquare(_v2, _v0);\n\n      if (next <= 1 && d2 < d) {\n        t = next;\n        d = d2;\n      } else {\n        interval *= 0.5;\n      }\n    }\n  } // t\n\n\n  if (out) {\n    out[0] = quadraticAt(x0, x1, x2, t);\n    out[1] = quadraticAt(y0, y1, y2, t);\n  } // console.log(interval, i);\n\n\n  return mathSqrt(d);\n}\n\nexports.cubicAt = cubicAt;\nexports.cubicDerivativeAt = cubicDerivativeAt;\nexports.cubicRootAt = cubicRootAt;\nexports.cubicExtrema = cubicExtrema;\nexports.cubicSubdivide = cubicSubdivide;\nexports.cubicProjectPoint = cubicProjectPoint;\nexports.quadraticAt = quadraticAt;\nexports.quadraticDerivativeAt = quadraticDerivativeAt;\nexports.quadraticRootAt = quadraticRootAt;\nexports.quadraticExtremum = quadraticExtremum;\nexports.quadraticSubdivide = quadraticSubdivide;\nexports.quadraticProjectPoint = quadraticProjectPoint;","module.exports = __WEBPACK_EXTERNAL_MODULE__5__;","\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n// (1) The code `if (__DEV__) ...` can be removed by build tool.\n// (2) If intend to use `__DEV__`, this module should be imported. Use a global\n// variable `__DEV__` may cause that miss the declaration (see #6535), or the\n// declaration is behind of the using position (for example in `Model.extent`,\n// And tools like rollup can not analysis the dependency if not import).\nvar dev; // In browser\n\nif (typeof window !== 'undefined') {\n  dev = window.__DEV__;\n} // In node\nelse if (typeof global !== 'undefined') {\n    dev = global.__DEV__;\n  }\n\nif (typeof dev === 'undefined') {\n  dev = true;\n}\n\nvar __DEV__ = dev;\nexports.__DEV__ = __DEV__;","var zrUtil = require(\"../core/util\");\n\nvar Style = require(\"./Style\");\n\nvar Element = require(\"../Element\");\n\nvar RectText = require(\"./mixin/RectText\");\n\n/**\n * 可绘制的图形基类\n * Base class of all displayable graphic objects\n * @module zrender/graphic/Displayable\n */\n\n/**\n * @alias module:zrender/graphic/Displayable\n * @extends module:zrender/Element\n * @extends module:zrender/graphic/mixin/RectText\n */\nfunction Displayable(opts) {\n  opts = opts || {};\n  Element.call(this, opts); // Extend properties\n\n  for (var name in opts) {\n    if (opts.hasOwnProperty(name) && name !== 'style') {\n      this[name] = opts[name];\n    }\n  }\n  /**\n   * @type {module:zrender/graphic/Style}\n   */\n\n\n  this.style = new Style(opts.style, this);\n  this._rect = null; // Shapes for cascade clipping.\n\n  this.__clipPaths = []; // FIXME Stateful must be mixined after style is setted\n  // Stateful.call(this, opts);\n}\n\nDisplayable.prototype = {\n  constructor: Displayable,\n  type: 'displayable',\n\n  /**\n   * Displayable 是否为脏，Painter 中会根据该标记判断是否需要是否需要重新绘制\n   * Dirty flag. From which painter will determine if this displayable object needs brush\n   * @name module:zrender/graphic/Displayable#__dirty\n   * @type {boolean}\n   */\n  __dirty: true,\n\n  /**\n   * 图形是否可见，为true时不绘制图形，但是仍能触发鼠标事件\n   * If ignore drawing of the displayable object. Mouse event will still be triggered\n   * @name module:/zrender/graphic/Displayable#invisible\n   * @type {boolean}\n   * @default false\n   */\n  invisible: false,\n\n  /**\n   * @name module:/zrender/graphic/Displayable#z\n   * @type {number}\n   * @default 0\n   */\n  z: 0,\n\n  /**\n   * @name module:/zrender/graphic/Displayable#z\n   * @type {number}\n   * @default 0\n   */\n  z2: 0,\n\n  /**\n   * z层level，决定绘画在哪层canvas中\n   * @name module:/zrender/graphic/Displayable#zlevel\n   * @type {number}\n   * @default 0\n   */\n  zlevel: 0,\n\n  /**\n   * 是否可拖拽\n   * @name module:/zrender/graphic/Displayable#draggable\n   * @type {boolean}\n   * @default false\n   */\n  draggable: false,\n\n  /**\n   * 是否正在拖拽\n   * @name module:/zrender/graphic/Displayable#draggable\n   * @type {boolean}\n   * @default false\n   */\n  dragging: false,\n\n  /**\n   * 是否相应鼠标事件\n   * @name module:/zrender/graphic/Displayable#silent\n   * @type {boolean}\n   * @default false\n   */\n  silent: false,\n\n  /**\n   * If enable culling\n   * @type {boolean}\n   * @default false\n   */\n  culling: false,\n\n  /**\n   * Mouse cursor when hovered\n   * @name module:/zrender/graphic/Displayable#cursor\n   * @type {string}\n   */\n  cursor: 'pointer',\n\n  /**\n   * If hover area is bounding rect\n   * @name module:/zrender/graphic/Displayable#rectHover\n   * @type {string}\n   */\n  rectHover: false,\n\n  /**\n   * Render the element progressively when the value >= 0,\n   * usefull for large data.\n   * @type {boolean}\n   */\n  progressive: false,\n\n  /**\n   * @type {boolean}\n   */\n  incremental: false,\n\n  /**\n   * Scale ratio for global scale.\n   * @type {boolean}\n   */\n  globalScaleRatio: 1,\n  beforeBrush: function (ctx) {},\n  afterBrush: function (ctx) {},\n\n  /**\n   * 图形绘制方法\n   * @param {CanvasRenderingContext2D} ctx\n   */\n  // Interface\n  brush: function (ctx, prevEl) {},\n\n  /**\n   * 获取最小包围盒\n   * @return {module:zrender/core/BoundingRect}\n   */\n  // Interface\n  getBoundingRect: function () {},\n\n  /**\n   * 判断坐标 x, y 是否在图形上\n   * If displayable element contain coord x, y\n   * @param  {number} x\n   * @param  {number} y\n   * @return {boolean}\n   */\n  contain: function (x, y) {\n    return this.rectContain(x, y);\n  },\n\n  /**\n   * @param  {Function} cb\n   * @param  {}   context\n   */\n  traverse: function (cb, context) {\n    cb.call(context, this);\n  },\n\n  /**\n   * 判断坐标 x, y 是否在图形的包围盒上\n   * If bounding rect of element contain coord x, y\n   * @param  {number} x\n   * @param  {number} y\n   * @return {boolean}\n   */\n  rectContain: function (x, y) {\n    var coord = this.transformCoordToLocal(x, y);\n    var rect = this.getBoundingRect();\n    return rect.contain(coord[0], coord[1]);\n  },\n\n  /**\n   * 标记图形元素为脏，并且在下一帧重绘\n   * Mark displayable element dirty and refresh next frame\n   */\n  dirty: function () {\n    this.__dirty = this.__dirtyText = true;\n    this._rect = null;\n    this.__zr && this.__zr.refresh();\n  },\n\n  /**\n   * 图形是否会触发事件\n   * If displayable object binded any event\n   * @return {boolean}\n   */\n  // TODO, 通过 bind 绑定的事件\n  // isSilent: function () {\n  //     return !(\n  //         this.hoverable || this.draggable\n  //         || this.onmousemove || this.onmouseover || this.onmouseout\n  //         || this.onmousedown || this.onmouseup || this.onclick\n  //         || this.ondragenter || this.ondragover || this.ondragleave\n  //         || this.ondrop\n  //     );\n  // },\n\n  /**\n   * Alias for animate('style')\n   * @param {boolean} loop\n   */\n  animateStyle: function (loop) {\n    return this.animate('style', loop);\n  },\n  attrKV: function (key, value) {\n    if (key !== 'style') {\n      Element.prototype.attrKV.call(this, key, value);\n    } else {\n      this.style.set(value);\n    }\n  },\n\n  /**\n   * @param {Object|string} key\n   * @param {*} value\n   */\n  setStyle: function (key, value) {\n    this.style.set(key, value);\n    this.dirty(false);\n    return this;\n  },\n\n  /**\n   * Use given style object\n   * @param  {Object} obj\n   */\n  useStyle: function (obj) {\n    this.style = new Style(obj, this);\n    this.dirty(false);\n    return this;\n  }\n};\nzrUtil.inherits(Displayable, Element);\nzrUtil.mixin(Displayable, RectText); // zrUtil.mixin(Displayable, Stateful);\n\nvar _default = Displayable;\nmodule.exports = _default;","var ContextCachedBy = {\n  NONE: 0,\n  STYLE_BIND: 1,\n  PLAIN_TEXT: 2\n}; // Avoid confused with 0/false.\n\nvar WILL_BE_RESTORED = 9;\nexports.ContextCachedBy = ContextCachedBy;\nexports.WILL_BE_RESTORED = WILL_BE_RESTORED;","var curve = require(\"./curve\");\n\nvar vec2 = require(\"./vector\");\n\nvar bbox = require(\"./bbox\");\n\nvar BoundingRect = require(\"./BoundingRect\");\n\nvar _config = require(\"../config\");\n\nvar dpr = _config.devicePixelRatio;\n\n/**\n * Path 代理，可以在`buildPath`中用于替代`ctx`, 会保存每个path操作的命令到pathCommands属性中\n * 可以用于 isInsidePath 判断以及获取boundingRect\n *\n * @module zrender/core/PathProxy\n * @author Yi Shen (http://www.github.com/pissang)\n */\n// TODO getTotalLength, getPointAtLength\nvar CMD = {\n  M: 1,\n  L: 2,\n  C: 3,\n  Q: 4,\n  A: 5,\n  Z: 6,\n  // Rect\n  R: 7\n}; // var CMD_MEM_SIZE = {\n//     M: 3,\n//     L: 3,\n//     C: 7,\n//     Q: 5,\n//     A: 9,\n//     R: 5,\n//     Z: 1\n// };\n\nvar min = [];\nvar max = [];\nvar min2 = [];\nvar max2 = [];\nvar mathMin = Math.min;\nvar mathMax = Math.max;\nvar mathCos = Math.cos;\nvar mathSin = Math.sin;\nvar mathSqrt = Math.sqrt;\nvar mathAbs = Math.abs;\nvar hasTypedArray = typeof Float32Array !== 'undefined';\n/**\n * @alias module:zrender/core/PathProxy\n * @constructor\n */\n\nvar PathProxy = function (notSaveData) {\n  this._saveData = !(notSaveData || false);\n\n  if (this._saveData) {\n    /**\n     * Path data. Stored as flat array\n     * @type {Array.<Object>}\n     */\n    this.data = [];\n  }\n\n  this._ctx = null;\n};\n/**\n * 快速计算Path包围盒（并不是最小包围盒）\n * @return {Object}\n */\n\n\nPathProxy.prototype = {\n  constructor: PathProxy,\n  _xi: 0,\n  _yi: 0,\n  _x0: 0,\n  _y0: 0,\n  // Unit x, Unit y. Provide for avoiding drawing that too short line segment\n  _ux: 0,\n  _uy: 0,\n  _len: 0,\n  _lineDash: null,\n  _dashOffset: 0,\n  _dashIdx: 0,\n  _dashSum: 0,\n\n  /**\n   * @readOnly\n   */\n  setScale: function (sx, sy) {\n    this._ux = mathAbs(1 / dpr / sx) || 0;\n    this._uy = mathAbs(1 / dpr / sy) || 0;\n  },\n  getContext: function () {\n    return this._ctx;\n  },\n\n  /**\n   * @param  {CanvasRenderingContext2D} ctx\n   * @return {module:zrender/core/PathProxy}\n   */\n  beginPath: function (ctx) {\n    this._ctx = ctx;\n    ctx && ctx.beginPath();\n    ctx && (this.dpr = ctx.dpr); // Reset\n\n    if (this._saveData) {\n      this._len = 0;\n    }\n\n    if (this._lineDash) {\n      this._lineDash = null;\n      this._dashOffset = 0;\n    }\n\n    return this;\n  },\n\n  /**\n   * @param  {number} x\n   * @param  {number} y\n   * @return {module:zrender/core/PathProxy}\n   */\n  moveTo: function (x, y) {\n    this.addData(CMD.M, x, y);\n    this._ctx && this._ctx.moveTo(x, y); // x0, y0, xi, yi 是记录在 _dashedXXXXTo 方法中使用\n    // xi, yi 记录当前点, x0, y0 在 closePath 的时候回到起始点。\n    // 有可能在 beginPath 之后直接调用 lineTo，这时候 x0, y0 需要\n    // 在 lineTo 方法中记录，这里先不考虑这种情况，dashed line 也只在 IE10- 中不支持\n\n    this._x0 = x;\n    this._y0 = y;\n    this._xi = x;\n    this._yi = y;\n    return this;\n  },\n\n  /**\n   * @param  {number} x\n   * @param  {number} y\n   * @return {module:zrender/core/PathProxy}\n   */\n  lineTo: function (x, y) {\n    var exceedUnit = mathAbs(x - this._xi) > this._ux || mathAbs(y - this._yi) > this._uy // Force draw the first segment\n    || this._len < 5;\n    this.addData(CMD.L, x, y);\n\n    if (this._ctx && exceedUnit) {\n      this._needsDash() ? this._dashedLineTo(x, y) : this._ctx.lineTo(x, y);\n    }\n\n    if (exceedUnit) {\n      this._xi = x;\n      this._yi = y;\n    }\n\n    return this;\n  },\n\n  /**\n   * @param  {number} x1\n   * @param  {number} y1\n   * @param  {number} x2\n   * @param  {number} y2\n   * @param  {number} x3\n   * @param  {number} y3\n   * @return {module:zrender/core/PathProxy}\n   */\n  bezierCurveTo: function (x1, y1, x2, y2, x3, y3) {\n    this.addData(CMD.C, x1, y1, x2, y2, x3, y3);\n\n    if (this._ctx) {\n      this._needsDash() ? this._dashedBezierTo(x1, y1, x2, y2, x3, y3) : this._ctx.bezierCurveTo(x1, y1, x2, y2, x3, y3);\n    }\n\n    this._xi = x3;\n    this._yi = y3;\n    return this;\n  },\n\n  /**\n   * @param  {number} x1\n   * @param  {number} y1\n   * @param  {number} x2\n   * @param  {number} y2\n   * @return {module:zrender/core/PathProxy}\n   */\n  quadraticCurveTo: function (x1, y1, x2, y2) {\n    this.addData(CMD.Q, x1, y1, x2, y2);\n\n    if (this._ctx) {\n      this._needsDash() ? this._dashedQuadraticTo(x1, y1, x2, y2) : this._ctx.quadraticCurveTo(x1, y1, x2, y2);\n    }\n\n    this._xi = x2;\n    this._yi = y2;\n    return this;\n  },\n\n  /**\n   * @param  {number} cx\n   * @param  {number} cy\n   * @param  {number} r\n   * @param  {number} startAngle\n   * @param  {number} endAngle\n   * @param  {boolean} anticlockwise\n   * @return {module:zrender/core/PathProxy}\n   */\n  arc: function (cx, cy, r, startAngle, endAngle, anticlockwise) {\n    this.addData(CMD.A, cx, cy, r, r, startAngle, endAngle - startAngle, 0, anticlockwise ? 0 : 1);\n    this._ctx && this._ctx.arc(cx, cy, r, startAngle, endAngle, anticlockwise);\n    this._xi = mathCos(endAngle) * r + cx;\n    this._yi = mathSin(endAngle) * r + cy;\n    return this;\n  },\n  // TODO\n  arcTo: function (x1, y1, x2, y2, radius) {\n    if (this._ctx) {\n      this._ctx.arcTo(x1, y1, x2, y2, radius);\n    }\n\n    return this;\n  },\n  // TODO\n  rect: function (x, y, w, h) {\n    this._ctx && this._ctx.rect(x, y, w, h);\n    this.addData(CMD.R, x, y, w, h);\n    return this;\n  },\n\n  /**\n   * @return {module:zrender/core/PathProxy}\n   */\n  closePath: function () {\n    this.addData(CMD.Z);\n    var ctx = this._ctx;\n    var x0 = this._x0;\n    var y0 = this._y0;\n\n    if (ctx) {\n      this._needsDash() && this._dashedLineTo(x0, y0);\n      ctx.closePath();\n    }\n\n    this._xi = x0;\n    this._yi = y0;\n    return this;\n  },\n\n  /**\n   * Context 从外部传入，因为有可能是 rebuildPath 完之后再 fill。\n   * stroke 同样\n   * @param {CanvasRenderingContext2D} ctx\n   * @return {module:zrender/core/PathProxy}\n   */\n  fill: function (ctx) {\n    ctx && ctx.fill();\n    this.toStatic();\n  },\n\n  /**\n   * @param {CanvasRenderingContext2D} ctx\n   * @return {module:zrender/core/PathProxy}\n   */\n  stroke: function (ctx) {\n    ctx && ctx.stroke();\n    this.toStatic();\n  },\n\n  /**\n   * 必须在其它绘制命令前调用\n   * Must be invoked before all other path drawing methods\n   * @return {module:zrender/core/PathProxy}\n   */\n  setLineDash: function (lineDash) {\n    if (lineDash instanceof Array) {\n      this._lineDash = lineDash;\n      this._dashIdx = 0;\n      var lineDashSum = 0;\n\n      for (var i = 0; i < lineDash.length; i++) {\n        lineDashSum += lineDash[i];\n      }\n\n      this._dashSum = lineDashSum;\n    }\n\n    return this;\n  },\n\n  /**\n   * 必须在其它绘制命令前调用\n   * Must be invoked before all other path drawing methods\n   * @return {module:zrender/core/PathProxy}\n   */\n  setLineDashOffset: function (offset) {\n    this._dashOffset = offset;\n    return this;\n  },\n\n  /**\n   *\n   * @return {boolean}\n   */\n  len: function () {\n    return this._len;\n  },\n\n  /**\n   * 直接设置 Path 数据\n   */\n  setData: function (data) {\n    var len = data.length;\n\n    if (!(this.data && this.data.length === len) && hasTypedArray) {\n      this.data = new Float32Array(len);\n    }\n\n    for (var i = 0; i < len; i++) {\n      this.data[i] = data[i];\n    }\n\n    this._len = len;\n  },\n\n  /**\n   * 添加子路径\n   * @param {module:zrender/core/PathProxy|Array.<module:zrender/core/PathProxy>} path\n   */\n  appendPath: function (path) {\n    if (!(path instanceof Array)) {\n      path = [path];\n    }\n\n    var len = path.length;\n    var appendSize = 0;\n    var offset = this._len;\n\n    for (var i = 0; i < len; i++) {\n      appendSize += path[i].len();\n    }\n\n    if (hasTypedArray && this.data instanceof Float32Array) {\n      this.data = new Float32Array(offset + appendSize);\n    }\n\n    for (var i = 0; i < len; i++) {\n      var appendPathData = path[i].data;\n\n      for (var k = 0; k < appendPathData.length; k++) {\n        this.data[offset++] = appendPathData[k];\n      }\n    }\n\n    this._len = offset;\n  },\n\n  /**\n   * 填充 Path 数据。\n   * 尽量复用而不申明新的数组。大部分图形重绘的指令数据长度都是不变的。\n   */\n  addData: function (cmd) {\n    if (!this._saveData) {\n      return;\n    }\n\n    var data = this.data;\n\n    if (this._len + arguments.length > data.length) {\n      // 因为之前的数组已经转换成静态的 Float32Array\n      // 所以不够用时需要扩展一个新的动态数组\n      this._expandData();\n\n      data = this.data;\n    }\n\n    for (var i = 0; i < arguments.length; i++) {\n      data[this._len++] = arguments[i];\n    }\n\n    this._prevCmd = cmd;\n  },\n  _expandData: function () {\n    // Only if data is Float32Array\n    if (!(this.data instanceof Array)) {\n      var newData = [];\n\n      for (var i = 0; i < this._len; i++) {\n        newData[i] = this.data[i];\n      }\n\n      this.data = newData;\n    }\n  },\n\n  /**\n   * If needs js implemented dashed line\n   * @return {boolean}\n   * @private\n   */\n  _needsDash: function () {\n    return this._lineDash;\n  },\n  _dashedLineTo: function (x1, y1) {\n    var dashSum = this._dashSum;\n    var offset = this._dashOffset;\n    var lineDash = this._lineDash;\n    var ctx = this._ctx;\n    var x0 = this._xi;\n    var y0 = this._yi;\n    var dx = x1 - x0;\n    var dy = y1 - y0;\n    var dist = mathSqrt(dx * dx + dy * dy);\n    var x = x0;\n    var y = y0;\n    var dash;\n    var nDash = lineDash.length;\n    var idx;\n    dx /= dist;\n    dy /= dist;\n\n    if (offset < 0) {\n      // Convert to positive offset\n      offset = dashSum + offset;\n    }\n\n    offset %= dashSum;\n    x -= offset * dx;\n    y -= offset * dy;\n\n    while (dx > 0 && x <= x1 || dx < 0 && x >= x1 || dx === 0 && (dy > 0 && y <= y1 || dy < 0 && y >= y1)) {\n      idx = this._dashIdx;\n      dash = lineDash[idx];\n      x += dx * dash;\n      y += dy * dash;\n      this._dashIdx = (idx + 1) % nDash; // Skip positive offset\n\n      if (dx > 0 && x < x0 || dx < 0 && x > x0 || dy > 0 && y < y0 || dy < 0 && y > y0) {\n        continue;\n      }\n\n      ctx[idx % 2 ? 'moveTo' : 'lineTo'](dx >= 0 ? mathMin(x, x1) : mathMax(x, x1), dy >= 0 ? mathMin(y, y1) : mathMax(y, y1));\n    } // Offset for next lineTo\n\n\n    dx = x - x1;\n    dy = y - y1;\n    this._dashOffset = -mathSqrt(dx * dx + dy * dy);\n  },\n  // Not accurate dashed line to\n  _dashedBezierTo: function (x1, y1, x2, y2, x3, y3) {\n    var dashSum = this._dashSum;\n    var offset = this._dashOffset;\n    var lineDash = this._lineDash;\n    var ctx = this._ctx;\n    var x0 = this._xi;\n    var y0 = this._yi;\n    var t;\n    var dx;\n    var dy;\n    var cubicAt = curve.cubicAt;\n    var bezierLen = 0;\n    var idx = this._dashIdx;\n    var nDash = lineDash.length;\n    var x;\n    var y;\n    var tmpLen = 0;\n\n    if (offset < 0) {\n      // Convert to positive offset\n      offset = dashSum + offset;\n    }\n\n    offset %= dashSum; // Bezier approx length\n\n    for (t = 0; t < 1; t += 0.1) {\n      dx = cubicAt(x0, x1, x2, x3, t + 0.1) - cubicAt(x0, x1, x2, x3, t);\n      dy = cubicAt(y0, y1, y2, y3, t + 0.1) - cubicAt(y0, y1, y2, y3, t);\n      bezierLen += mathSqrt(dx * dx + dy * dy);\n    } // Find idx after add offset\n\n\n    for (; idx < nDash; idx++) {\n      tmpLen += lineDash[idx];\n\n      if (tmpLen > offset) {\n        break;\n      }\n    }\n\n    t = (tmpLen - offset) / bezierLen;\n\n    while (t <= 1) {\n      x = cubicAt(x0, x1, x2, x3, t);\n      y = cubicAt(y0, y1, y2, y3, t); // Use line to approximate dashed bezier\n      // Bad result if dash is long\n\n      idx % 2 ? ctx.moveTo(x, y) : ctx.lineTo(x, y);\n      t += lineDash[idx] / bezierLen;\n      idx = (idx + 1) % nDash;\n    } // Finish the last segment and calculate the new offset\n\n\n    idx % 2 !== 0 && ctx.lineTo(x3, y3);\n    dx = x3 - x;\n    dy = y3 - y;\n    this._dashOffset = -mathSqrt(dx * dx + dy * dy);\n  },\n  _dashedQuadraticTo: function (x1, y1, x2, y2) {\n    // Convert quadratic to cubic using degree elevation\n    var x3 = x2;\n    var y3 = y2;\n    x2 = (x2 + 2 * x1) / 3;\n    y2 = (y2 + 2 * y1) / 3;\n    x1 = (this._xi + 2 * x1) / 3;\n    y1 = (this._yi + 2 * y1) / 3;\n\n    this._dashedBezierTo(x1, y1, x2, y2, x3, y3);\n  },\n\n  /**\n   * 转成静态的 Float32Array 减少堆内存占用\n   * Convert dynamic array to static Float32Array\n   */\n  toStatic: function () {\n    var data = this.data;\n\n    if (data instanceof Array) {\n      data.length = this._len;\n\n      if (hasTypedArray) {\n        this.data = new Float32Array(data);\n      }\n    }\n  },\n\n  /**\n   * @return {module:zrender/core/BoundingRect}\n   */\n  getBoundingRect: function () {\n    min[0] = min[1] = min2[0] = min2[1] = Number.MAX_VALUE;\n    max[0] = max[1] = max2[0] = max2[1] = -Number.MAX_VALUE;\n    var data = this.data;\n    var xi = 0;\n    var yi = 0;\n    var x0 = 0;\n    var y0 = 0;\n\n    for (var i = 0; i < data.length;) {\n      var cmd = data[i++];\n\n      if (i === 1) {\n        // 如果第一个命令是 L, C, Q\n        // 则 previous point 同绘制命令的第一个 point\n        //\n        // 第一个命令为 Arc 的情况下会在后面特殊处理\n        xi = data[i];\n        yi = data[i + 1];\n        x0 = xi;\n        y0 = yi;\n      }\n\n      switch (cmd) {\n        case CMD.M:\n          // moveTo 命令重新创建一个新的 subpath, 并且更新新的起点\n          // 在 closePath 的时候使用\n          x0 = data[i++];\n          y0 = data[i++];\n          xi = x0;\n          yi = y0;\n          min2[0] = x0;\n          min2[1] = y0;\n          max2[0] = x0;\n          max2[1] = y0;\n          break;\n\n        case CMD.L:\n          bbox.fromLine(xi, yi, data[i], data[i + 1], min2, max2);\n          xi = data[i++];\n          yi = data[i++];\n          break;\n\n        case CMD.C:\n          bbox.fromCubic(xi, yi, data[i++], data[i++], data[i++], data[i++], data[i], data[i + 1], min2, max2);\n          xi = data[i++];\n          yi = data[i++];\n          break;\n\n        case CMD.Q:\n          bbox.fromQuadratic(xi, yi, data[i++], data[i++], data[i], data[i + 1], min2, max2);\n          xi = data[i++];\n          yi = data[i++];\n          break;\n\n        case CMD.A:\n          // TODO Arc 判断的开销比较大\n          var cx = data[i++];\n          var cy = data[i++];\n          var rx = data[i++];\n          var ry = data[i++];\n          var startAngle = data[i++];\n          var endAngle = data[i++] + startAngle; // TODO Arc 旋转\n\n          i += 1;\n          var anticlockwise = 1 - data[i++];\n\n          if (i === 1) {\n            // 直接使用 arc 命令\n            // 第一个命令起点还未定义\n            x0 = mathCos(startAngle) * rx + cx;\n            y0 = mathSin(startAngle) * ry + cy;\n          }\n\n          bbox.fromArc(cx, cy, rx, ry, startAngle, endAngle, anticlockwise, min2, max2);\n          xi = mathCos(endAngle) * rx + cx;\n          yi = mathSin(endAngle) * ry + cy;\n          break;\n\n        case CMD.R:\n          x0 = xi = data[i++];\n          y0 = yi = data[i++];\n          var width = data[i++];\n          var height = data[i++]; // Use fromLine\n\n          bbox.fromLine(x0, y0, x0 + width, y0 + height, min2, max2);\n          break;\n\n        case CMD.Z:\n          xi = x0;\n          yi = y0;\n          break;\n      } // Union\n\n\n      vec2.min(min, min, min2);\n      vec2.max(max, max, max2);\n    } // No data\n\n\n    if (i === 0) {\n      min[0] = min[1] = max[0] = max[1] = 0;\n    }\n\n    return new BoundingRect(min[0], min[1], max[0] - min[0], max[1] - min[1]);\n  },\n\n  /**\n   * Rebuild path from current data\n   * Rebuild path will not consider javascript implemented line dash.\n   * @param {CanvasRenderingContext2D} ctx\n   */\n  rebuildPath: function (ctx) {\n    var d = this.data;\n    var x0, y0;\n    var xi, yi;\n    var x, y;\n    var ux = this._ux;\n    var uy = this._uy;\n    var len = this._len;\n\n    for (var i = 0; i < len;) {\n      var cmd = d[i++];\n\n      if (i === 1) {\n        // 如果第一个命令是 L, C, Q\n        // 则 previous point 同绘制命令的第一个 point\n        //\n        // 第一个命令为 Arc 的情况下会在后面特殊处理\n        xi = d[i];\n        yi = d[i + 1];\n        x0 = xi;\n        y0 = yi;\n      }\n\n      switch (cmd) {\n        case CMD.M:\n          x0 = xi = d[i++];\n          y0 = yi = d[i++];\n          ctx.moveTo(xi, yi);\n          break;\n\n        case CMD.L:\n          x = d[i++];\n          y = d[i++]; // Not draw too small seg between\n\n          if (mathAbs(x - xi) > ux || mathAbs(y - yi) > uy || i === len - 1) {\n            ctx.lineTo(x, y);\n            xi = x;\n            yi = y;\n          }\n\n          break;\n\n        case CMD.C:\n          ctx.bezierCurveTo(d[i++], d[i++], d[i++], d[i++], d[i++], d[i++]);\n          xi = d[i - 2];\n          yi = d[i - 1];\n          break;\n\n        case CMD.Q:\n          ctx.quadraticCurveTo(d[i++], d[i++], d[i++], d[i++]);\n          xi = d[i - 2];\n          yi = d[i - 1];\n          break;\n\n        case CMD.A:\n          var cx = d[i++];\n          var cy = d[i++];\n          var rx = d[i++];\n          var ry = d[i++];\n          var theta = d[i++];\n          var dTheta = d[i++];\n          var psi = d[i++];\n          var fs = d[i++];\n          var r = rx > ry ? rx : ry;\n          var scaleX = rx > ry ? 1 : rx / ry;\n          var scaleY = rx > ry ? ry / rx : 1;\n          var isEllipse = Math.abs(rx - ry) > 1e-3;\n          var endAngle = theta + dTheta;\n\n          if (isEllipse) {\n            ctx.translate(cx, cy);\n            ctx.rotate(psi);\n            ctx.scale(scaleX, scaleY);\n            ctx.arc(0, 0, r, theta, endAngle, 1 - fs);\n            ctx.scale(1 / scaleX, 1 / scaleY);\n            ctx.rotate(-psi);\n            ctx.translate(-cx, -cy);\n          } else {\n            ctx.arc(cx, cy, r, theta, endAngle, 1 - fs);\n          }\n\n          if (i === 1) {\n            // 直接使用 arc 命令\n            // 第一个命令起点还未定义\n            x0 = mathCos(theta) * rx + cx;\n            y0 = mathSin(theta) * ry + cy;\n          }\n\n          xi = mathCos(endAngle) * rx + cx;\n          yi = mathSin(endAngle) * ry + cy;\n          break;\n\n        case CMD.R:\n          x0 = xi = d[i];\n          y0 = yi = d[i + 1];\n          ctx.rect(d[i++], d[i++], d[i++], d[i++]);\n          break;\n\n        case CMD.Z:\n          ctx.closePath();\n          xi = x0;\n          yi = y0;\n      }\n    }\n  }\n};\nPathProxy.CMD = CMD;\nvar _default = PathProxy;\nmodule.exports = _default;","/**\n * 3x2矩阵操作类\n * @exports zrender/tool/matrix\n */\nvar ArrayCtor = typeof Float32Array === 'undefined' ? Array : Float32Array;\n/**\n * Create a identity matrix.\n * @return {Float32Array|Array.<number>}\n */\n\nfunction create() {\n  var out = new ArrayCtor(6);\n  identity(out);\n  return out;\n}\n/**\n * 设置矩阵为单位矩阵\n * @param {Float32Array|Array.<number>} out\n */\n\n\nfunction identity(out) {\n  out[0] = 1;\n  out[1] = 0;\n  out[2] = 0;\n  out[3] = 1;\n  out[4] = 0;\n  out[5] = 0;\n  return out;\n}\n/**\n * 复制矩阵\n * @param {Float32Array|Array.<number>} out\n * @param {Float32Array|Array.<number>} m\n */\n\n\nfunction copy(out, m) {\n  out[0] = m[0];\n  out[1] = m[1];\n  out[2] = m[2];\n  out[3] = m[3];\n  out[4] = m[4];\n  out[5] = m[5];\n  return out;\n}\n/**\n * 矩阵相乘\n * @param {Float32Array|Array.<number>} out\n * @param {Float32Array|Array.<number>} m1\n * @param {Float32Array|Array.<number>} m2\n */\n\n\nfunction mul(out, m1, m2) {\n  // Consider matrix.mul(m, m2, m);\n  // where out is the same as m2.\n  // So use temp variable to escape error.\n  var out0 = m1[0] * m2[0] + m1[2] * m2[1];\n  var out1 = m1[1] * m2[0] + m1[3] * m2[1];\n  var out2 = m1[0] * m2[2] + m1[2] * m2[3];\n  var out3 = m1[1] * m2[2] + m1[3] * m2[3];\n  var out4 = m1[0] * m2[4] + m1[2] * m2[5] + m1[4];\n  var out5 = m1[1] * m2[4] + m1[3] * m2[5] + m1[5];\n  out[0] = out0;\n  out[1] = out1;\n  out[2] = out2;\n  out[3] = out3;\n  out[4] = out4;\n  out[5] = out5;\n  return out;\n}\n/**\n * 平移变换\n * @param {Float32Array|Array.<number>} out\n * @param {Float32Array|Array.<number>} a\n * @param {Float32Array|Array.<number>} v\n */\n\n\nfunction translate(out, a, v) {\n  out[0] = a[0];\n  out[1] = a[1];\n  out[2] = a[2];\n  out[3] = a[3];\n  out[4] = a[4] + v[0];\n  out[5] = a[5] + v[1];\n  return out;\n}\n/**\n * 旋转变换\n * @param {Float32Array|Array.<number>} out\n * @param {Float32Array|Array.<number>} a\n * @param {number} rad\n */\n\n\nfunction rotate(out, a, rad) {\n  var aa = a[0];\n  var ac = a[2];\n  var atx = a[4];\n  var ab = a[1];\n  var ad = a[3];\n  var aty = a[5];\n  var st = Math.sin(rad);\n  var ct = Math.cos(rad);\n  out[0] = aa * ct + ab * st;\n  out[1] = -aa * st + ab * ct;\n  out[2] = ac * ct + ad * st;\n  out[3] = -ac * st + ct * ad;\n  out[4] = ct * atx + st * aty;\n  out[5] = ct * aty - st * atx;\n  return out;\n}\n/**\n * 缩放变换\n * @param {Float32Array|Array.<number>} out\n * @param {Float32Array|Array.<number>} a\n * @param {Float32Array|Array.<number>} v\n */\n\n\nfunction scale(out, a, v) {\n  var vx = v[0];\n  var vy = v[1];\n  out[0] = a[0] * vx;\n  out[1] = a[1] * vy;\n  out[2] = a[2] * vx;\n  out[3] = a[3] * vy;\n  out[4] = a[4] * vx;\n  out[5] = a[5] * vy;\n  return out;\n}\n/**\n * 求逆矩阵\n * @param {Float32Array|Array.<number>} out\n * @param {Float32Array|Array.<number>} a\n */\n\n\nfunction invert(out, a) {\n  var aa = a[0];\n  var ac = a[2];\n  var atx = a[4];\n  var ab = a[1];\n  var ad = a[3];\n  var aty = a[5];\n  var det = aa * ad - ab * ac;\n\n  if (!det) {\n    return null;\n  }\n\n  det = 1.0 / det;\n  out[0] = ad * det;\n  out[1] = -ab * det;\n  out[2] = -ac * det;\n  out[3] = aa * det;\n  out[4] = (ac * aty - ad * atx) * det;\n  out[5] = (ab * atx - aa * aty) * det;\n  return out;\n}\n/**\n * Clone a new matrix.\n * @param {Float32Array|Array.<number>} a\n */\n\n\nfunction clone(a) {\n  var b = create();\n  copy(b, a);\n  return b;\n}\n\nexports.create = create;\nexports.identity = identity;\nexports.copy = copy;\nexports.mul = mul;\nexports.translate = translate;\nexports.rotate = rotate;\nexports.scale = scale;\nexports.invert = invert;\nexports.clone = clone;","var LRU = require(\"../../core/LRU\");\n\nvar globalImageCache = new LRU(50);\n/**\n * @param {string|HTMLImageElement|HTMLCanvasElement|Canvas} newImageOrSrc\n * @return {HTMLImageElement|HTMLCanvasElement|Canvas} image\n */\n\nfunction findExistImage(newImageOrSrc) {\n  if (typeof newImageOrSrc === 'string') {\n    var cachedImgObj = globalImageCache.get(newImageOrSrc);\n    return cachedImgObj && cachedImgObj.image;\n  } else {\n    return newImageOrSrc;\n  }\n}\n/**\n * Caution: User should cache loaded images, but not just count on LRU.\n * Consider if required images more than LRU size, will dead loop occur?\n *\n * @param {string|HTMLImageElement|HTMLCanvasElement|Canvas} newImageOrSrc\n * @param {HTMLImageElement|HTMLCanvasElement|Canvas} image Existent image.\n * @param {module:zrender/Element} [hostEl] For calling `dirty`.\n * @param {Function} [cb] params: (image, cbPayload)\n * @param {Object} [cbPayload] Payload on cb calling.\n * @return {HTMLImageElement|HTMLCanvasElement|Canvas} image\n */\n\n\nfunction createOrUpdateImage(newImageOrSrc, image, hostEl, cb, cbPayload) {\n  if (!newImageOrSrc) {\n    return image;\n  } else if (typeof newImageOrSrc === 'string') {\n    // Image should not be loaded repeatly.\n    if (image && image.__zrImageSrc === newImageOrSrc || !hostEl) {\n      return image;\n    } // Only when there is no existent image or existent image src\n    // is different, this method is responsible for load.\n\n\n    var cachedImgObj = globalImageCache.get(newImageOrSrc);\n    var pendingWrap = {\n      hostEl: hostEl,\n      cb: cb,\n      cbPayload: cbPayload\n    };\n\n    if (cachedImgObj) {\n      image = cachedImgObj.image;\n      !isImageReady(image) && cachedImgObj.pending.push(pendingWrap);\n    } else {\n      image = new Image();\n      image.onload = image.onerror = imageOnLoad;\n      globalImageCache.put(newImageOrSrc, image.__cachedImgObj = {\n        image: image,\n        pending: [pendingWrap]\n      });\n      image.src = image.__zrImageSrc = newImageOrSrc;\n    }\n\n    return image;\n  } // newImageOrSrc is an HTMLImageElement or HTMLCanvasElement or Canvas\n  else {\n      return newImageOrSrc;\n    }\n}\n\nfunction imageOnLoad() {\n  var cachedImgObj = this.__cachedImgObj;\n  this.onload = this.onerror = this.__cachedImgObj = null;\n\n  for (var i = 0; i < cachedImgObj.pending.length; i++) {\n    var pendingWrap = cachedImgObj.pending[i];\n    var cb = pendingWrap.cb;\n    cb && cb(this, pendingWrap.cbPayload);\n    pendingWrap.hostEl.dirty();\n  }\n\n  cachedImgObj.pending.length = 0;\n}\n\nfunction isImageReady(image) {\n  return image && image.width && image.height;\n}\n\nexports.findExistImage = findExistImage;\nexports.createOrUpdateImage = createOrUpdateImage;\nexports.isImageReady = isImageReady;","\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar zrUtil = require(\"zrender/lib/core/util\");\n\nvar env = require(\"zrender/lib/core/env\");\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\nvar each = zrUtil.each;\nvar isObject = zrUtil.isObject;\nvar isArray = zrUtil.isArray;\n/**\n * Make the name displayable. But we should\n * make sure it is not duplicated with user\n * specified name, so use '\\0';\n */\n\nvar DUMMY_COMPONENT_NAME_PREFIX = 'series\\0';\n/**\n * If value is not array, then translate it to array.\n * @param  {*} value\n * @return {Array} [value] or value\n */\n\nfunction normalizeToArray(value) {\n  return value instanceof Array ? value : value == null ? [] : [value];\n}\n/**\n * Sync default option between normal and emphasis like `position` and `show`\n * In case some one will write code like\n *     label: {\n *          show: false,\n *          position: 'outside',\n *          fontSize: 18\n *     },\n *     emphasis: {\n *          label: { show: true }\n *     }\n * @param {Object} opt\n * @param {string} key\n * @param {Array.<string>} subOpts\n */\n\n\nfunction defaultEmphasis(opt, key, subOpts) {\n  // Caution: performance sensitive.\n  if (opt) {\n    opt[key] = opt[key] || {};\n    opt.emphasis = opt.emphasis || {};\n    opt.emphasis[key] = opt.emphasis[key] || {}; // Default emphasis option from normal\n\n    for (var i = 0, len = subOpts.length; i < len; i++) {\n      var subOptName = subOpts[i];\n\n      if (!opt.emphasis[key].hasOwnProperty(subOptName) && opt[key].hasOwnProperty(subOptName)) {\n        opt.emphasis[key][subOptName] = opt[key][subOptName];\n      }\n    }\n  }\n}\n\nvar TEXT_STYLE_OPTIONS = ['fontStyle', 'fontWeight', 'fontSize', 'fontFamily', 'rich', 'tag', 'color', 'textBorderColor', 'textBorderWidth', 'width', 'height', 'lineHeight', 'align', 'verticalAlign', 'baseline', 'shadowColor', 'shadowBlur', 'shadowOffsetX', 'shadowOffsetY', 'textShadowColor', 'textShadowBlur', 'textShadowOffsetX', 'textShadowOffsetY', 'backgroundColor', 'borderColor', 'borderWidth', 'borderRadius', 'padding']; // modelUtil.LABEL_OPTIONS = modelUtil.TEXT_STYLE_OPTIONS.concat([\n//     'position', 'offset', 'rotate', 'origin', 'show', 'distance', 'formatter',\n//     'fontStyle', 'fontWeight', 'fontSize', 'fontFamily',\n//     // FIXME: deprecated, check and remove it.\n//     'textStyle'\n// ]);\n\n/**\n * The method do not ensure performance.\n * data could be [12, 2323, {value: 223}, [1221, 23], {value: [2, 23]}]\n * This helper method retieves value from data.\n * @param {string|number|Date|Array|Object} dataItem\n * @return {number|string|Date|Array.<number|string|Date>}\n */\n\nfunction getDataItemValue(dataItem) {\n  return isObject(dataItem) && !isArray(dataItem) && !(dataItem instanceof Date) ? dataItem.value : dataItem;\n}\n/**\n * data could be [12, 2323, {value: 223}, [1221, 23], {value: [2, 23]}]\n * This helper method determine if dataItem has extra option besides value\n * @param {string|number|Date|Array|Object} dataItem\n */\n\n\nfunction isDataItemOption(dataItem) {\n  return isObject(dataItem) && !(dataItem instanceof Array); // // markLine data can be array\n  // && !(dataItem[0] && isObject(dataItem[0]) && !(dataItem[0] instanceof Array));\n}\n/**\n * Mapping to exists for merge.\n *\n * @public\n * @param {Array.<Object>|Array.<module:echarts/model/Component>} exists\n * @param {Object|Array.<Object>} newCptOptions\n * @return {Array.<Object>} Result, like [{exist: ..., option: ...}, {}],\n *                          index of which is the same as exists.\n */\n\n\nfunction mappingToExists(exists, newCptOptions) {\n  // Mapping by the order by original option (but not order of\n  // new option) in merge mode. Because we should ensure\n  // some specified index (like xAxisIndex) is consistent with\n  // original option, which is easy to understand, espatially in\n  // media query. And in most case, merge option is used to\n  // update partial option but not be expected to change order.\n  newCptOptions = (newCptOptions || []).slice();\n  var result = zrUtil.map(exists || [], function (obj, index) {\n    return {\n      exist: obj\n    };\n  }); // Mapping by id or name if specified.\n\n  each(newCptOptions, function (cptOption, index) {\n    if (!isObject(cptOption)) {\n      return;\n    } // id has highest priority.\n\n\n    for (var i = 0; i < result.length; i++) {\n      if (!result[i].option // Consider name: two map to one.\n      && cptOption.id != null && result[i].exist.id === cptOption.id + '') {\n        result[i].option = cptOption;\n        newCptOptions[index] = null;\n        return;\n      }\n    }\n\n    for (var i = 0; i < result.length; i++) {\n      var exist = result[i].exist;\n\n      if (!result[i].option // Consider name: two map to one.\n      // Can not match when both ids exist but different.\n      && (exist.id == null || cptOption.id == null) && cptOption.name != null && !isIdInner(cptOption) && !isIdInner(exist) && exist.name === cptOption.name + '') {\n        result[i].option = cptOption;\n        newCptOptions[index] = null;\n        return;\n      }\n    }\n  }); // Otherwise mapping by index.\n\n  each(newCptOptions, function (cptOption, index) {\n    if (!isObject(cptOption)) {\n      return;\n    }\n\n    var i = 0;\n\n    for (; i < result.length; i++) {\n      var exist = result[i].exist;\n\n      if (!result[i].option // Existing model that already has id should be able to\n      // mapped to (because after mapping performed model may\n      // be assigned with a id, whish should not affect next\n      // mapping), except those has inner id.\n      && !isIdInner(exist) // Caution:\n      // Do not overwrite id. But name can be overwritten,\n      // because axis use name as 'show label text'.\n      // 'exist' always has id and name and we dont\n      // need to check it.\n      && cptOption.id == null) {\n        result[i].option = cptOption;\n        break;\n      }\n    }\n\n    if (i >= result.length) {\n      result.push({\n        option: cptOption\n      });\n    }\n  });\n  return result;\n}\n/**\n * Make id and name for mapping result (result of mappingToExists)\n * into `keyInfo` field.\n *\n * @public\n * @param {Array.<Object>} Result, like [{exist: ..., option: ...}, {}],\n *                          which order is the same as exists.\n * @return {Array.<Object>} The input.\n */\n\n\nfunction makeIdAndName(mapResult) {\n  // We use this id to hash component models and view instances\n  // in echarts. id can be specified by user, or auto generated.\n  // The id generation rule ensures new view instance are able\n  // to mapped to old instance when setOption are called in\n  // no-merge mode. So we generate model id by name and plus\n  // type in view id.\n  // name can be duplicated among components, which is convenient\n  // to specify multi components (like series) by one name.\n  // Ensure that each id is distinct.\n  var idMap = zrUtil.createHashMap();\n  each(mapResult, function (item, index) {\n    var existCpt = item.exist;\n    existCpt && idMap.set(existCpt.id, item);\n  });\n  each(mapResult, function (item, index) {\n    var opt = item.option;\n    zrUtil.assert(!opt || opt.id == null || !idMap.get(opt.id) || idMap.get(opt.id) === item, 'id duplicates: ' + (opt && opt.id));\n    opt && opt.id != null && idMap.set(opt.id, item);\n    !item.keyInfo && (item.keyInfo = {});\n  }); // Make name and id.\n\n  each(mapResult, function (item, index) {\n    var existCpt = item.exist;\n    var opt = item.option;\n    var keyInfo = item.keyInfo;\n\n    if (!isObject(opt)) {\n      return;\n    } // name can be overwitten. Consider case: axis.name = '20km'.\n    // But id generated by name will not be changed, which affect\n    // only in that case: setOption with 'not merge mode' and view\n    // instance will be recreated, which can be accepted.\n\n\n    keyInfo.name = opt.name != null ? opt.name + '' : existCpt ? existCpt.name // Avoid diffferent series has the same name,\n    // because name may be used like in color pallet.\n    : DUMMY_COMPONENT_NAME_PREFIX + index;\n\n    if (existCpt) {\n      keyInfo.id = existCpt.id;\n    } else if (opt.id != null) {\n      keyInfo.id = opt.id + '';\n    } else {\n      // Consider this situatoin:\n      //  optionA: [{name: 'a'}, {name: 'a'}, {..}]\n      //  optionB [{..}, {name: 'a'}, {name: 'a'}]\n      // Series with the same name between optionA and optionB\n      // should be mapped.\n      var idNum = 0;\n\n      do {\n        keyInfo.id = '\\0' + keyInfo.name + '\\0' + idNum++;\n      } while (idMap.get(keyInfo.id));\n    }\n\n    idMap.set(keyInfo.id, item);\n  });\n}\n\nfunction isNameSpecified(componentModel) {\n  var name = componentModel.name; // Is specified when `indexOf` get -1 or > 0.\n\n  return !!(name && name.indexOf(DUMMY_COMPONENT_NAME_PREFIX));\n}\n/**\n * @public\n * @param {Object} cptOption\n * @return {boolean}\n */\n\n\nfunction isIdInner(cptOption) {\n  return isObject(cptOption) && cptOption.id && (cptOption.id + '').indexOf('\\0_ec_\\0') === 0;\n}\n/**\n * A helper for removing duplicate items between batchA and batchB,\n * and in themselves, and categorize by series.\n *\n * @param {Array.<Object>} batchA Like: [{seriesId: 2, dataIndex: [32, 4, 5]}, ...]\n * @param {Array.<Object>} batchB Like: [{seriesId: 2, dataIndex: [32, 4, 5]}, ...]\n * @return {Array.<Array.<Object>, Array.<Object>>} result: [resultBatchA, resultBatchB]\n */\n\n\nfunction compressBatches(batchA, batchB) {\n  var mapA = {};\n  var mapB = {};\n  makeMap(batchA || [], mapA);\n  makeMap(batchB || [], mapB, mapA);\n  return [mapToArray(mapA), mapToArray(mapB)];\n\n  function makeMap(sourceBatch, map, otherMap) {\n    for (var i = 0, len = sourceBatch.length; i < len; i++) {\n      var seriesId = sourceBatch[i].seriesId;\n      var dataIndices = normalizeToArray(sourceBatch[i].dataIndex);\n      var otherDataIndices = otherMap && otherMap[seriesId];\n\n      for (var j = 0, lenj = dataIndices.length; j < lenj; j++) {\n        var dataIndex = dataIndices[j];\n\n        if (otherDataIndices && otherDataIndices[dataIndex]) {\n          otherDataIndices[dataIndex] = null;\n        } else {\n          (map[seriesId] || (map[seriesId] = {}))[dataIndex] = 1;\n        }\n      }\n    }\n  }\n\n  function mapToArray(map, isData) {\n    var result = [];\n\n    for (var i in map) {\n      if (map.hasOwnProperty(i) && map[i] != null) {\n        if (isData) {\n          result.push(+i);\n        } else {\n          var dataIndices = mapToArray(map[i], true);\n          dataIndices.length && result.push({\n            seriesId: i,\n            dataIndex: dataIndices\n          });\n        }\n      }\n    }\n\n    return result;\n  }\n}\n/**\n * @param {module:echarts/data/List} data\n * @param {Object} payload Contains dataIndex (means rawIndex) / dataIndexInside / name\n *                         each of which can be Array or primary type.\n * @return {number|Array.<number>} dataIndex If not found, return undefined/null.\n */\n\n\nfunction queryDataIndex(data, payload) {\n  if (payload.dataIndexInside != null) {\n    return payload.dataIndexInside;\n  } else if (payload.dataIndex != null) {\n    return zrUtil.isArray(payload.dataIndex) ? zrUtil.map(payload.dataIndex, function (value) {\n      return data.indexOfRawIndex(value);\n    }) : data.indexOfRawIndex(payload.dataIndex);\n  } else if (payload.name != null) {\n    return zrUtil.isArray(payload.name) ? zrUtil.map(payload.name, function (value) {\n      return data.indexOfName(value);\n    }) : data.indexOfName(payload.name);\n  }\n}\n/**\n * Enable property storage to any host object.\n * Notice: Serialization is not supported.\n *\n * For example:\n * var inner = zrUitl.makeInner();\n *\n * function some1(hostObj) {\n *      inner(hostObj).someProperty = 1212;\n *      ...\n * }\n * function some2() {\n *      var fields = inner(this);\n *      fields.someProperty1 = 1212;\n *      fields.someProperty2 = 'xx';\n *      ...\n * }\n *\n * @return {Function}\n */\n\n\nfunction makeInner() {\n  // Consider different scope by es module import.\n  var key = '__\\0ec_inner_' + innerUniqueIndex++ + '_' + Math.random().toFixed(5);\n  return function (hostObj) {\n    return hostObj[key] || (hostObj[key] = {});\n  };\n}\n\nvar innerUniqueIndex = 0;\n/**\n * @param {module:echarts/model/Global} ecModel\n * @param {string|Object} finder\n *        If string, e.g., 'geo', means {geoIndex: 0}.\n *        If Object, could contain some of these properties below:\n *        {\n *            seriesIndex, seriesId, seriesName,\n *            geoIndex, geoId, geoName,\n *            bmapIndex, bmapId, bmapName,\n *            xAxisIndex, xAxisId, xAxisName,\n *            yAxisIndex, yAxisId, yAxisName,\n *            gridIndex, gridId, gridName,\n *            ... (can be extended)\n *        }\n *        Each properties can be number|string|Array.<number>|Array.<string>\n *        For example, a finder could be\n *        {\n *            seriesIndex: 3,\n *            geoId: ['aa', 'cc'],\n *            gridName: ['xx', 'rr']\n *        }\n *        xxxIndex can be set as 'all' (means all xxx) or 'none' (means not specify)\n *        If nothing or null/undefined specified, return nothing.\n * @param {Object} [opt]\n * @param {string} [opt.defaultMainType]\n * @param {Array.<string>} [opt.includeMainTypes]\n * @return {Object} result like:\n *        {\n *            seriesModels: [seriesModel1, seriesModel2],\n *            seriesModel: seriesModel1, // The first model\n *            geoModels: [geoModel1, geoModel2],\n *            geoModel: geoModel1, // The first model\n *            ...\n *        }\n */\n\nfunction parseFinder(ecModel, finder, opt) {\n  if (zrUtil.isString(finder)) {\n    var obj = {};\n    obj[finder + 'Index'] = 0;\n    finder = obj;\n  }\n\n  var defaultMainType = opt && opt.defaultMainType;\n\n  if (defaultMainType && !has(finder, defaultMainType + 'Index') && !has(finder, defaultMainType + 'Id') && !has(finder, defaultMainType + 'Name')) {\n    finder[defaultMainType + 'Index'] = 0;\n  }\n\n  var result = {};\n  each(finder, function (value, key) {\n    var value = finder[key]; // Exclude 'dataIndex' and other illgal keys.\n\n    if (key === 'dataIndex' || key === 'dataIndexInside') {\n      result[key] = value;\n      return;\n    }\n\n    var parsedKey = key.match(/^(\\w+)(Index|Id|Name)$/) || [];\n    var mainType = parsedKey[1];\n    var queryType = (parsedKey[2] || '').toLowerCase();\n\n    if (!mainType || !queryType || value == null || queryType === 'index' && value === 'none' || opt && opt.includeMainTypes && zrUtil.indexOf(opt.includeMainTypes, mainType) < 0) {\n      return;\n    }\n\n    var queryParam = {\n      mainType: mainType\n    };\n\n    if (queryType !== 'index' || value !== 'all') {\n      queryParam[queryType] = value;\n    }\n\n    var models = ecModel.queryComponents(queryParam);\n    result[mainType + 'Models'] = models;\n    result[mainType + 'Model'] = models[0];\n  });\n  return result;\n}\n\nfunction has(obj, prop) {\n  return obj && obj.hasOwnProperty(prop);\n}\n\nfunction setAttribute(dom, key, value) {\n  dom.setAttribute ? dom.setAttribute(key, value) : dom[key] = value;\n}\n\nfunction getAttribute(dom, key) {\n  return dom.getAttribute ? dom.getAttribute(key) : dom[key];\n}\n\nfunction getTooltipRenderMode(renderModeOption) {\n  if (renderModeOption === 'auto') {\n    // Using html when `document` exists, use richText otherwise\n    return env.domSupported ? 'html' : 'richText';\n  } else {\n    return renderModeOption || 'html';\n  }\n}\n/**\n * Group a list by key.\n *\n * @param {Array} array\n * @param {Function} getKey\n *        param {*} Array item\n *        return {string} key\n * @return {Object} Result\n *        {Array}: keys,\n *        {module:zrender/core/util/HashMap} buckets: {key -> Array}\n */\n\n\nfunction groupData(array, getKey) {\n  var buckets = zrUtil.createHashMap();\n  var keys = [];\n  zrUtil.each(array, function (item) {\n    var key = getKey(item);\n    (buckets.get(key) || (keys.push(key), buckets.set(key, []))).push(item);\n  });\n  return {\n    keys: keys,\n    buckets: buckets\n  };\n}\n\nexports.normalizeToArray = normalizeToArray;\nexports.defaultEmphasis = defaultEmphasis;\nexports.TEXT_STYLE_OPTIONS = TEXT_STYLE_OPTIONS;\nexports.getDataItemValue = getDataItemValue;\nexports.isDataItemOption = isDataItemOption;\nexports.mappingToExists = mappingToExists;\nexports.makeIdAndName = makeIdAndName;\nexports.isNameSpecified = isNameSpecified;\nexports.isIdInner = isIdInner;\nexports.compressBatches = compressBatches;\nexports.queryDataIndex = queryDataIndex;\nexports.makeInner = makeInner;\nexports.parseFinder = parseFinder;\nexports.setAttribute = setAttribute;\nexports.getAttribute = getAttribute;\nexports.getTooltipRenderMode = getTooltipRenderMode;\nexports.groupData = groupData;","/**\n * echarts设备环境识别\n *\n * @desc echarts基于Canvas，纯Javascript图表库，提供直观，生动，可交互，可个性化定制的数据统计图表。\n * @author firede[firede@firede.us]\n * @desc thanks zepto.\n */\nvar env = {};\n\nif (typeof wx === 'object' && typeof wx.getSystemInfoSync === 'function') {\n  // In Weixin Application\n  env = {\n    browser: {},\n    os: {},\n    node: false,\n    wxa: true,\n    // Weixin Application\n    canvasSupported: true,\n    svgSupported: false,\n    touchEventsSupported: true,\n    domSupported: false\n  };\n} else if (typeof document === 'undefined' && typeof self !== 'undefined') {\n  // In worker\n  env = {\n    browser: {},\n    os: {},\n    node: false,\n    worker: true,\n    canvasSupported: true,\n    domSupported: false\n  };\n} else if (typeof navigator === 'undefined') {\n  // In node\n  env = {\n    browser: {},\n    os: {},\n    node: true,\n    worker: false,\n    // Assume canvas is supported\n    canvasSupported: true,\n    svgSupported: true,\n    domSupported: false\n  };\n} else {\n  env = detect(navigator.userAgent);\n}\n\nvar _default = env; // Zepto.js\n// (c) 2010-2013 Thomas Fuchs\n// Zepto.js may be freely distributed under the MIT license.\n\nfunction detect(ua) {\n  var os = {};\n  var browser = {}; // var webkit = ua.match(/Web[kK]it[\\/]{0,1}([\\d.]+)/);\n  // var android = ua.match(/(Android);?[\\s\\/]+([\\d.]+)?/);\n  // var ipad = ua.match(/(iPad).*OS\\s([\\d_]+)/);\n  // var ipod = ua.match(/(iPod)(.*OS\\s([\\d_]+))?/);\n  // var iphone = !ipad && ua.match(/(iPhone\\sOS)\\s([\\d_]+)/);\n  // var webos = ua.match(/(webOS|hpwOS)[\\s\\/]([\\d.]+)/);\n  // var touchpad = webos && ua.match(/TouchPad/);\n  // var kindle = ua.match(/Kindle\\/([\\d.]+)/);\n  // var silk = ua.match(/Silk\\/([\\d._]+)/);\n  // var blackberry = ua.match(/(BlackBerry).*Version\\/([\\d.]+)/);\n  // var bb10 = ua.match(/(BB10).*Version\\/([\\d.]+)/);\n  // var rimtabletos = ua.match(/(RIM\\sTablet\\sOS)\\s([\\d.]+)/);\n  // var playbook = ua.match(/PlayBook/);\n  // var chrome = ua.match(/Chrome\\/([\\d.]+)/) || ua.match(/CriOS\\/([\\d.]+)/);\n\n  var firefox = ua.match(/Firefox\\/([\\d.]+)/); // var safari = webkit && ua.match(/Mobile\\//) && !chrome;\n  // var webview = ua.match(/(iPhone|iPod|iPad).*AppleWebKit(?!.*Safari)/) && !chrome;\n\n  var ie = ua.match(/MSIE\\s([\\d.]+)/) // IE 11 Trident/7.0; rv:11.0\n  || ua.match(/Trident\\/.+?rv:(([\\d.]+))/);\n  var edge = ua.match(/Edge\\/([\\d.]+)/); // IE 12 and 12+\n\n  var weChat = /micromessenger/i.test(ua); // Todo: clean this up with a better OS/browser seperation:\n  // - discern (more) between multiple browsers on android\n  // - decide if kindle fire in silk mode is android or not\n  // - Firefox on Android doesn't specify the Android version\n  // - possibly devide in os, device and browser hashes\n  // if (browser.webkit = !!webkit) browser.version = webkit[1];\n  // if (android) os.android = true, os.version = android[2];\n  // if (iphone && !ipod) os.ios = os.iphone = true, os.version = iphone[2].replace(/_/g, '.');\n  // if (ipad) os.ios = os.ipad = true, os.version = ipad[2].replace(/_/g, '.');\n  // if (ipod) os.ios = os.ipod = true, os.version = ipod[3] ? ipod[3].replace(/_/g, '.') : null;\n  // if (webos) os.webos = true, os.version = webos[2];\n  // if (touchpad) os.touchpad = true;\n  // if (blackberry) os.blackberry = true, os.version = blackberry[2];\n  // if (bb10) os.bb10 = true, os.version = bb10[2];\n  // if (rimtabletos) os.rimtabletos = true, os.version = rimtabletos[2];\n  // if (playbook) browser.playbook = true;\n  // if (kindle) os.kindle = true, os.version = kindle[1];\n  // if (silk) browser.silk = true, browser.version = silk[1];\n  // if (!silk && os.android && ua.match(/Kindle Fire/)) browser.silk = true;\n  // if (chrome) browser.chrome = true, browser.version = chrome[1];\n\n  if (firefox) {\n    browser.firefox = true;\n    browser.version = firefox[1];\n  } // if (safari && (ua.match(/Safari/) || !!os.ios)) browser.safari = true;\n  // if (webview) browser.webview = true;\n\n\n  if (ie) {\n    browser.ie = true;\n    browser.version = ie[1];\n  }\n\n  if (edge) {\n    browser.edge = true;\n    browser.version = edge[1];\n  } // It is difficult to detect WeChat in Win Phone precisely, because ua can\n  // not be set on win phone. So we do not consider Win Phone.\n\n\n  if (weChat) {\n    browser.weChat = true;\n  } // os.tablet = !!(ipad || playbook || (android && !ua.match(/Mobile/)) ||\n  //     (firefox && ua.match(/Tablet/)) || (ie && !ua.match(/Phone/) && ua.match(/Touch/)));\n  // os.phone  = !!(!os.tablet && !os.ipod && (android || iphone || webos ||\n  //     (chrome && ua.match(/Android/)) || (chrome && ua.match(/CriOS\\/([\\d.]+)/)) ||\n  //     (firefox && ua.match(/Mobile/)) || (ie && ua.match(/Touch/))));\n\n\n  return {\n    browser: browser,\n    os: os,\n    node: false,\n    // 原生canvas支持，改极端点了\n    // canvasSupported : !(browser.ie && parseFloat(browser.version) < 9)\n    canvasSupported: !!document.createElement('canvas').getContext,\n    svgSupported: typeof SVGRect !== 'undefined',\n    // works on most browsers\n    // IE10/11 does not support touch event, and MS Edge supports them but not by\n    // default, so we dont check navigator.maxTouchPoints for them here.\n    touchEventsSupported: 'ontouchstart' in window && !browser.ie && !browser.edge,\n    // <http://caniuse.com/#search=pointer%20event>.\n    pointerEventsSupported: 'onpointerdown' in window // Firefox supports pointer but not by default, only MS browsers are reliable on pointer\n    // events currently. So we dont use that on other browsers unless tested sufficiently.\n    // Although IE 10 supports pointer event, it use old style and is different from the\n    // standard. So we exclude that. (IE 10 is hardly used on touch device)\n    && (browser.edge || browser.ie && browser.version >= 11),\n    // passiveSupported: detectPassiveSupport()\n    domSupported: typeof document !== 'undefined'\n  };\n} // See https://github.com/WICG/EventListenerOptions/blob/gh-pages/explainer.md#feature-detection\n// function detectPassiveSupport() {\n//     // Test via a getter in the options object to see if the passive property is accessed\n//     var supportsPassive = false;\n//     try {\n//         var opts = Object.defineProperty({}, 'passive', {\n//             get: function() {\n//                 supportsPassive = true;\n//             }\n//         });\n//         window.addEventListener('testPassive', function() {}, opts);\n//     } catch (e) {\n//     }\n//     return supportsPassive;\n// }\n\n\nmodule.exports = _default;","\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar _util = require(\"zrender/lib/core/util\");\n\nvar createHashMap = _util.createHashMap;\nvar isTypedArray = _util.isTypedArray;\n\nvar _clazz = require(\"../util/clazz\");\n\nvar enableClassCheck = _clazz.enableClassCheck;\n\nvar _sourceType = require(\"./helper/sourceType\");\n\nvar SOURCE_FORMAT_ORIGINAL = _sourceType.SOURCE_FORMAT_ORIGINAL;\nvar SERIES_LAYOUT_BY_COLUMN = _sourceType.SERIES_LAYOUT_BY_COLUMN;\nvar SOURCE_FORMAT_UNKNOWN = _sourceType.SOURCE_FORMAT_UNKNOWN;\nvar SOURCE_FORMAT_TYPED_ARRAY = _sourceType.SOURCE_FORMAT_TYPED_ARRAY;\nvar SOURCE_FORMAT_KEYED_COLUMNS = _sourceType.SOURCE_FORMAT_KEYED_COLUMNS;\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n/**\n * [sourceFormat]\n *\n * + \"original\":\n * This format is only used in series.data, where\n * itemStyle can be specified in data item.\n *\n * + \"arrayRows\":\n * [\n *     ['product', 'score', 'amount'],\n *     ['Matcha Latte', 89.3, 95.8],\n *     ['Milk Tea', 92.1, 89.4],\n *     ['Cheese Cocoa', 94.4, 91.2],\n *     ['Walnut Brownie', 85.4, 76.9]\n * ]\n *\n * + \"objectRows\":\n * [\n *     {product: 'Matcha Latte', score: 89.3, amount: 95.8},\n *     {product: 'Milk Tea', score: 92.1, amount: 89.4},\n *     {product: 'Cheese Cocoa', score: 94.4, amount: 91.2},\n *     {product: 'Walnut Brownie', score: 85.4, amount: 76.9}\n * ]\n *\n * + \"keyedColumns\":\n * {\n *     'product': ['Matcha Latte', 'Milk Tea', 'Cheese Cocoa', 'Walnut Brownie'],\n *     'count': [823, 235, 1042, 988],\n *     'score': [95.8, 81.4, 91.2, 76.9]\n * }\n *\n * + \"typedArray\"\n *\n * + \"unknown\"\n */\n\n/**\n * @constructor\n * @param {Object} fields\n * @param {string} fields.sourceFormat\n * @param {Array|Object} fields.fromDataset\n * @param {Array|Object} [fields.data]\n * @param {string} [seriesLayoutBy='column']\n * @param {Array.<Object|string>} [dimensionsDefine]\n * @param {Objet|HashMap} [encodeDefine]\n * @param {number} [startIndex=0]\n * @param {number} [dimensionsDetectCount]\n */\nfunction Source(fields) {\n  /**\n   * @type {boolean}\n   */\n  this.fromDataset = fields.fromDataset;\n  /**\n   * Not null/undefined.\n   * @type {Array|Object}\n   */\n\n  this.data = fields.data || (fields.sourceFormat === SOURCE_FORMAT_KEYED_COLUMNS ? {} : []);\n  /**\n   * See also \"detectSourceFormat\".\n   * Not null/undefined.\n   * @type {string}\n   */\n\n  this.sourceFormat = fields.sourceFormat || SOURCE_FORMAT_UNKNOWN;\n  /**\n   * 'row' or 'column'\n   * Not null/undefined.\n   * @type {string} seriesLayoutBy\n   */\n\n  this.seriesLayoutBy = fields.seriesLayoutBy || SERIES_LAYOUT_BY_COLUMN;\n  /**\n   * dimensions definition in option.\n   * can be null/undefined.\n   * @type {Array.<Object|string>}\n   */\n\n  this.dimensionsDefine = fields.dimensionsDefine;\n  /**\n   * encode definition in option.\n   * can be null/undefined.\n   * @type {Objet|HashMap}\n   */\n\n  this.encodeDefine = fields.encodeDefine && createHashMap(fields.encodeDefine);\n  /**\n   * Not null/undefined, uint.\n   * @type {number}\n   */\n\n  this.startIndex = fields.startIndex || 0;\n  /**\n   * Can be null/undefined (when unknown), uint.\n   * @type {number}\n   */\n\n  this.dimensionsDetectCount = fields.dimensionsDetectCount;\n}\n/**\n * Wrap original series data for some compatibility cases.\n */\n\n\nSource.seriesDataToSource = function (data) {\n  return new Source({\n    data: data,\n    sourceFormat: isTypedArray(data) ? SOURCE_FORMAT_TYPED_ARRAY : SOURCE_FORMAT_ORIGINAL,\n    fromDataset: false\n  });\n};\n\nenableClassCheck(Source);\nvar _default = Source;\nmodule.exports = _default;","\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n// Avoid typo.\nvar SOURCE_FORMAT_ORIGINAL = 'original';\nvar SOURCE_FORMAT_ARRAY_ROWS = 'arrayRows';\nvar SOURCE_FORMAT_OBJECT_ROWS = 'objectRows';\nvar SOURCE_FORMAT_KEYED_COLUMNS = 'keyedColumns';\nvar SOURCE_FORMAT_UNKNOWN = 'unknown'; // ??? CHANGE A NAME\n\nvar SOURCE_FORMAT_TYPED_ARRAY = 'typedArray';\nvar SERIES_LAYOUT_BY_COLUMN = 'column';\nvar SERIES_LAYOUT_BY_ROW = 'row';\nexports.SOURCE_FORMAT_ORIGINAL = SOURCE_FORMAT_ORIGINAL;\nexports.SOURCE_FORMAT_ARRAY_ROWS = SOURCE_FORMAT_ARRAY_ROWS;\nexports.SOURCE_FORMAT_OBJECT_ROWS = SOURCE_FORMAT_OBJECT_ROWS;\nexports.SOURCE_FORMAT_KEYED_COLUMNS = SOURCE_FORMAT_KEYED_COLUMNS;\nexports.SOURCE_FORMAT_UNKNOWN = SOURCE_FORMAT_UNKNOWN;\nexports.SOURCE_FORMAT_TYPED_ARRAY = SOURCE_FORMAT_TYPED_ARRAY;\nexports.SERIES_LAYOUT_BY_COLUMN = SERIES_LAYOUT_BY_COLUMN;\nexports.SERIES_LAYOUT_BY_ROW = SERIES_LAYOUT_BY_ROW;","var SHADOW_PROPS = {\n  'shadowBlur': 1,\n  'shadowOffsetX': 1,\n  'shadowOffsetY': 1,\n  'textShadowBlur': 1,\n  'textShadowOffsetX': 1,\n  'textShadowOffsetY': 1,\n  'textBoxShadowBlur': 1,\n  'textBoxShadowOffsetX': 1,\n  'textBoxShadowOffsetY': 1\n};\n\nfunction _default(ctx, propName, value) {\n  if (SHADOW_PROPS.hasOwnProperty(propName)) {\n    return value *= ctx.dpr;\n  }\n\n  return value;\n}\n\nmodule.exports = _default;","var guid = require(\"./core/guid\");\n\nvar Eventful = require(\"./mixin/Eventful\");\n\nvar Transformable = require(\"./mixin/Transformable\");\n\nvar Animatable = require(\"./mixin/Animatable\");\n\nvar zrUtil = require(\"./core/util\");\n\n/**\n * @alias module:zrender/Element\n * @constructor\n * @extends {module:zrender/mixin/Animatable}\n * @extends {module:zrender/mixin/Transformable}\n * @extends {module:zrender/mixin/Eventful}\n */\nvar Element = function (opts) {\n  // jshint ignore:line\n  Transformable.call(this, opts);\n  Eventful.call(this, opts);\n  Animatable.call(this, opts);\n  /**\n   * 画布元素ID\n   * @type {string}\n   */\n\n  this.id = opts.id || guid();\n};\n\nElement.prototype = {\n  /**\n   * 元素类型\n   * Element type\n   * @type {string}\n   */\n  type: 'element',\n\n  /**\n   * 元素名字\n   * Element name\n   * @type {string}\n   */\n  name: '',\n\n  /**\n   * ZRender 实例对象，会在 element 添加到 zrender 实例中后自动赋值\n   * ZRender instance will be assigned when element is associated with zrender\n   * @name module:/zrender/Element#__zr\n   * @type {module:zrender/ZRender}\n   */\n  __zr: null,\n\n  /**\n   * 图形是否忽略，为true时忽略图形的绘制以及事件触发\n   * If ignore drawing and events of the element object\n   * @name module:/zrender/Element#ignore\n   * @type {boolean}\n   * @default false\n   */\n  ignore: false,\n\n  /**\n   * 用于裁剪的路径(shape)，所有 Group 内的路径在绘制时都会被这个路径裁剪\n   * 该路径会继承被裁减对象的变换\n   * @type {module:zrender/graphic/Path}\n   * @see http://www.w3.org/TR/2dcontext/#clipping-region\n   * @readOnly\n   */\n  clipPath: null,\n\n  /**\n   * 是否是 Group\n   * @type {boolean}\n   */\n  isGroup: false,\n\n  /**\n   * Drift element\n   * @param  {number} dx dx on the global space\n   * @param  {number} dy dy on the global space\n   */\n  drift: function (dx, dy) {\n    switch (this.draggable) {\n      case 'horizontal':\n        dy = 0;\n        break;\n\n      case 'vertical':\n        dx = 0;\n        break;\n    }\n\n    var m = this.transform;\n\n    if (!m) {\n      m = this.transform = [1, 0, 0, 1, 0, 0];\n    }\n\n    m[4] += dx;\n    m[5] += dy;\n    this.decomposeTransform();\n    this.dirty(false);\n  },\n\n  /**\n   * Hook before update\n   */\n  beforeUpdate: function () {},\n\n  /**\n   * Hook after update\n   */\n  afterUpdate: function () {},\n\n  /**\n   * Update each frame\n   */\n  update: function () {\n    this.updateTransform();\n  },\n\n  /**\n   * @param  {Function} cb\n   * @param  {}   context\n   */\n  traverse: function (cb, context) {},\n\n  /**\n   * @protected\n   */\n  attrKV: function (key, value) {\n    if (key === 'position' || key === 'scale' || key === 'origin') {\n      // Copy the array\n      if (value) {\n        var target = this[key];\n\n        if (!target) {\n          target = this[key] = [];\n        }\n\n        target[0] = value[0];\n        target[1] = value[1];\n      }\n    } else {\n      this[key] = value;\n    }\n  },\n\n  /**\n   * Hide the element\n   */\n  hide: function () {\n    this.ignore = true;\n    this.__zr && this.__zr.refresh();\n  },\n\n  /**\n   * Show the element\n   */\n  show: function () {\n    this.ignore = false;\n    this.__zr && this.__zr.refresh();\n  },\n\n  /**\n   * @param {string|Object} key\n   * @param {*} value\n   */\n  attr: function (key, value) {\n    if (typeof key === 'string') {\n      this.attrKV(key, value);\n    } else if (zrUtil.isObject(key)) {\n      for (var name in key) {\n        if (key.hasOwnProperty(name)) {\n          this.attrKV(name, key[name]);\n        }\n      }\n    }\n\n    this.dirty(false);\n    return this;\n  },\n\n  /**\n   * @param {module:zrender/graphic/Path} clipPath\n   */\n  setClipPath: function (clipPath) {\n    var zr = this.__zr;\n\n    if (zr) {\n      clipPath.addSelfToZr(zr);\n    } // Remove previous clip path\n\n\n    if (this.clipPath && this.clipPath !== clipPath) {\n      this.removeClipPath();\n    }\n\n    this.clipPath = clipPath;\n    clipPath.__zr = zr;\n    clipPath.__clipTarget = this;\n    this.dirty(false);\n  },\n\n  /**\n   */\n  removeClipPath: function () {\n    var clipPath = this.clipPath;\n\n    if (clipPath) {\n      if (clipPath.__zr) {\n        clipPath.removeSelfFromZr(clipPath.__zr);\n      }\n\n      clipPath.__zr = null;\n      clipPath.__clipTarget = null;\n      this.clipPath = null;\n      this.dirty(false);\n    }\n  },\n\n  /**\n   * Add self from zrender instance.\n   * Not recursively because it will be invoked when element added to storage.\n   * @param {module:zrender/ZRender} zr\n   */\n  addSelfToZr: function (zr) {\n    this.__zr = zr; // 添加动画\n\n    var animators = this.animators;\n\n    if (animators) {\n      for (var i = 0; i < animators.length; i++) {\n        zr.animation.addAnimator(animators[i]);\n      }\n    }\n\n    if (this.clipPath) {\n      this.clipPath.addSelfToZr(zr);\n    }\n  },\n\n  /**\n   * Remove self from zrender instance.\n   * Not recursively because it will be invoked when element added to storage.\n   * @param {module:zrender/ZRender} zr\n   */\n  removeSelfFromZr: function (zr) {\n    this.__zr = null; // 移除动画\n\n    var animators = this.animators;\n\n    if (animators) {\n      for (var i = 0; i < animators.length; i++) {\n        zr.animation.removeAnimator(animators[i]);\n      }\n    }\n\n    if (this.clipPath) {\n      this.clipPath.removeSelfFromZr(zr);\n    }\n  }\n};\nzrUtil.mixin(Element, Animatable);\nzrUtil.mixin(Element, Transformable);\nzrUtil.mixin(Element, Eventful);\nvar _default = Element;\nmodule.exports = _default;","var matrix = require(\"../core/matrix\");\n\nvar vector = require(\"../core/vector\");\n\n/**\n * 提供变换扩展\n * @module zrender/mixin/Transformable\n * @author pissang (https://www.github.com/pissang)\n */\nvar mIdentity = matrix.identity;\nvar EPSILON = 5e-5;\n\nfunction isNotAroundZero(val) {\n  return val > EPSILON || val < -EPSILON;\n}\n/**\n * @alias module:zrender/mixin/Transformable\n * @constructor\n */\n\n\nvar Transformable = function (opts) {\n  opts = opts || {}; // If there are no given position, rotation, scale\n\n  if (!opts.position) {\n    /**\n     * 平移\n     * @type {Array.<number>}\n     * @default [0, 0]\n     */\n    this.position = [0, 0];\n  }\n\n  if (opts.rotation == null) {\n    /**\n     * 旋转\n     * @type {Array.<number>}\n     * @default 0\n     */\n    this.rotation = 0;\n  }\n\n  if (!opts.scale) {\n    /**\n     * 缩放\n     * @type {Array.<number>}\n     * @default [1, 1]\n     */\n    this.scale = [1, 1];\n  }\n  /**\n   * 旋转和缩放的原点\n   * @type {Array.<number>}\n   * @default null\n   */\n\n\n  this.origin = this.origin || null;\n};\n\nvar transformableProto = Transformable.prototype;\ntransformableProto.transform = null;\n/**\n * 判断是否需要有坐标变换\n * 如果有坐标变换, 则从position, rotation, scale以及父节点的transform计算出自身的transform矩阵\n */\n\ntransformableProto.needLocalTransform = function () {\n  return isNotAroundZero(this.rotation) || isNotAroundZero(this.position[0]) || isNotAroundZero(this.position[1]) || isNotAroundZero(this.scale[0] - 1) || isNotAroundZero(this.scale[1] - 1);\n};\n\nvar scaleTmp = [];\n\ntransformableProto.updateTransform = function () {\n  var parent = this.parent;\n  var parentHasTransform = parent && parent.transform;\n  var needLocalTransform = this.needLocalTransform();\n  var m = this.transform;\n\n  if (!(needLocalTransform || parentHasTransform)) {\n    m && mIdentity(m);\n    return;\n  }\n\n  m = m || matrix.create();\n\n  if (needLocalTransform) {\n    this.getLocalTransform(m);\n  } else {\n    mIdentity(m);\n  } // 应用父节点变换\n\n\n  if (parentHasTransform) {\n    if (needLocalTransform) {\n      matrix.mul(m, parent.transform, m);\n    } else {\n      matrix.copy(m, parent.transform);\n    }\n  } // 保存这个变换矩阵\n\n\n  this.transform = m;\n  var globalScaleRatio = this.globalScaleRatio;\n\n  if (globalScaleRatio != null && globalScaleRatio !== 1) {\n    this.getGlobalScale(scaleTmp);\n    var relX = scaleTmp[0] < 0 ? -1 : 1;\n    var relY = scaleTmp[1] < 0 ? -1 : 1;\n    var sx = ((scaleTmp[0] - relX) * globalScaleRatio + relX) / scaleTmp[0] || 0;\n    var sy = ((scaleTmp[1] - relY) * globalScaleRatio + relY) / scaleTmp[1] || 0;\n    m[0] *= sx;\n    m[1] *= sx;\n    m[2] *= sy;\n    m[3] *= sy;\n  }\n\n  this.invTransform = this.invTransform || matrix.create();\n  matrix.invert(this.invTransform, m);\n};\n\ntransformableProto.getLocalTransform = function (m) {\n  return Transformable.getLocalTransform(this, m);\n};\n/**\n * 将自己的transform应用到context上\n * @param {CanvasRenderingContext2D} ctx\n */\n\n\ntransformableProto.setTransform = function (ctx) {\n  var m = this.transform;\n  var dpr = ctx.dpr || 1;\n\n  if (m) {\n    ctx.setTransform(dpr * m[0], dpr * m[1], dpr * m[2], dpr * m[3], dpr * m[4], dpr * m[5]);\n  } else {\n    ctx.setTransform(dpr, 0, 0, dpr, 0, 0);\n  }\n};\n\ntransformableProto.restoreTransform = function (ctx) {\n  var dpr = ctx.dpr || 1;\n  ctx.setTransform(dpr, 0, 0, dpr, 0, 0);\n};\n\nvar tmpTransform = [];\nvar originTransform = matrix.create();\n\ntransformableProto.setLocalTransform = function (m) {\n  if (!m) {\n    // TODO return or set identity?\n    return;\n  }\n\n  var sx = m[0] * m[0] + m[1] * m[1];\n  var sy = m[2] * m[2] + m[3] * m[3];\n  var position = this.position;\n  var scale = this.scale;\n\n  if (isNotAroundZero(sx - 1)) {\n    sx = Math.sqrt(sx);\n  }\n\n  if (isNotAroundZero(sy - 1)) {\n    sy = Math.sqrt(sy);\n  }\n\n  if (m[0] < 0) {\n    sx = -sx;\n  }\n\n  if (m[3] < 0) {\n    sy = -sy;\n  }\n\n  position[0] = m[4];\n  position[1] = m[5];\n  scale[0] = sx;\n  scale[1] = sy;\n  this.rotation = Math.atan2(-m[1] / sy, m[0] / sx);\n};\n/**\n * 分解`transform`矩阵到`position`, `rotation`, `scale`\n */\n\n\ntransformableProto.decomposeTransform = function () {\n  if (!this.transform) {\n    return;\n  }\n\n  var parent = this.parent;\n  var m = this.transform;\n\n  if (parent && parent.transform) {\n    // Get local transform and decompose them to position, scale, rotation\n    matrix.mul(tmpTransform, parent.invTransform, m);\n    m = tmpTransform;\n  }\n\n  var origin = this.origin;\n\n  if (origin && (origin[0] || origin[1])) {\n    originTransform[4] = origin[0];\n    originTransform[5] = origin[1];\n    matrix.mul(tmpTransform, m, originTransform);\n    tmpTransform[4] -= origin[0];\n    tmpTransform[5] -= origin[1];\n    m = tmpTransform;\n  }\n\n  this.setLocalTransform(m);\n};\n/**\n * Get global scale\n * @return {Array.<number>}\n */\n\n\ntransformableProto.getGlobalScale = function (out) {\n  var m = this.transform;\n  out = out || [];\n\n  if (!m) {\n    out[0] = 1;\n    out[1] = 1;\n    return out;\n  }\n\n  out[0] = Math.sqrt(m[0] * m[0] + m[1] * m[1]);\n  out[1] = Math.sqrt(m[2] * m[2] + m[3] * m[3]);\n\n  if (m[0] < 0) {\n    out[0] = -out[0];\n  }\n\n  if (m[3] < 0) {\n    out[1] = -out[1];\n  }\n\n  return out;\n};\n/**\n * 变换坐标位置到 shape 的局部坐标空间\n * @method\n * @param {number} x\n * @param {number} y\n * @return {Array.<number>}\n */\n\n\ntransformableProto.transformCoordToLocal = function (x, y) {\n  var v2 = [x, y];\n  var invTransform = this.invTransform;\n\n  if (invTransform) {\n    vector.applyTransform(v2, v2, invTransform);\n  }\n\n  return v2;\n};\n/**\n * 变换局部坐标位置到全局坐标空间\n * @method\n * @param {number} x\n * @param {number} y\n * @return {Array.<number>}\n */\n\n\ntransformableProto.transformCoordToGlobal = function (x, y) {\n  var v2 = [x, y];\n  var transform = this.transform;\n\n  if (transform) {\n    vector.applyTransform(v2, v2, transform);\n  }\n\n  return v2;\n};\n/**\n * @static\n * @param {Object} target\n * @param {Array.<number>} target.origin\n * @param {number} target.rotation\n * @param {Array.<number>} target.position\n * @param {Array.<number>} [m]\n */\n\n\nTransformable.getLocalTransform = function (target, m) {\n  m = m || [];\n  mIdentity(m);\n  var origin = target.origin;\n  var scale = target.scale || [1, 1];\n  var rotation = target.rotation || 0;\n  var position = target.position || [0, 0];\n\n  if (origin) {\n    // Translate to origin\n    m[4] -= origin[0];\n    m[5] -= origin[1];\n  }\n\n  matrix.scale(m, m, scale);\n\n  if (rotation) {\n    matrix.rotate(m, m, rotation);\n  }\n\n  if (origin) {\n    // Translate back from origin\n    m[4] += origin[0];\n    m[5] += origin[1];\n  }\n\n  m[4] += position[0];\n  m[5] += position[1];\n  return m;\n};\n\nvar _default = Transformable;\nmodule.exports = _default;","var LRU = require(\"../core/LRU\");\n\nvar kCSSColorTable = {\n  'transparent': [0, 0, 0, 0],\n  'aliceblue': [240, 248, 255, 1],\n  'antiquewhite': [250, 235, 215, 1],\n  'aqua': [0, 255, 255, 1],\n  'aquamarine': [127, 255, 212, 1],\n  'azure': [240, 255, 255, 1],\n  'beige': [245, 245, 220, 1],\n  'bisque': [255, 228, 196, 1],\n  'black': [0, 0, 0, 1],\n  'blanchedalmond': [255, 235, 205, 1],\n  'blue': [0, 0, 255, 1],\n  'blueviolet': [138, 43, 226, 1],\n  'brown': [165, 42, 42, 1],\n  'burlywood': [222, 184, 135, 1],\n  'cadetblue': [95, 158, 160, 1],\n  'chartreuse': [127, 255, 0, 1],\n  'chocolate': [210, 105, 30, 1],\n  'coral': [255, 127, 80, 1],\n  'cornflowerblue': [100, 149, 237, 1],\n  'cornsilk': [255, 248, 220, 1],\n  'crimson': [220, 20, 60, 1],\n  'cyan': [0, 255, 255, 1],\n  'darkblue': [0, 0, 139, 1],\n  'darkcyan': [0, 139, 139, 1],\n  'darkgoldenrod': [184, 134, 11, 1],\n  'darkgray': [169, 169, 169, 1],\n  'darkgreen': [0, 100, 0, 1],\n  'darkgrey': [169, 169, 169, 1],\n  'darkkhaki': [189, 183, 107, 1],\n  'darkmagenta': [139, 0, 139, 1],\n  'darkolivegreen': [85, 107, 47, 1],\n  'darkorange': [255, 140, 0, 1],\n  'darkorchid': [153, 50, 204, 1],\n  'darkred': [139, 0, 0, 1],\n  'darksalmon': [233, 150, 122, 1],\n  'darkseagreen': [143, 188, 143, 1],\n  'darkslateblue': [72, 61, 139, 1],\n  'darkslategray': [47, 79, 79, 1],\n  'darkslategrey': [47, 79, 79, 1],\n  'darkturquoise': [0, 206, 209, 1],\n  'darkviolet': [148, 0, 211, 1],\n  'deeppink': [255, 20, 147, 1],\n  'deepskyblue': [0, 191, 255, 1],\n  'dimgray': [105, 105, 105, 1],\n  'dimgrey': [105, 105, 105, 1],\n  'dodgerblue': [30, 144, 255, 1],\n  'firebrick': [178, 34, 34, 1],\n  'floralwhite': [255, 250, 240, 1],\n  'forestgreen': [34, 139, 34, 1],\n  'fuchsia': [255, 0, 255, 1],\n  'gainsboro': [220, 220, 220, 1],\n  'ghostwhite': [248, 248, 255, 1],\n  'gold': [255, 215, 0, 1],\n  'goldenrod': [218, 165, 32, 1],\n  'gray': [128, 128, 128, 1],\n  'green': [0, 128, 0, 1],\n  'greenyellow': [173, 255, 47, 1],\n  'grey': [128, 128, 128, 1],\n  'honeydew': [240, 255, 240, 1],\n  'hotpink': [255, 105, 180, 1],\n  'indianred': [205, 92, 92, 1],\n  'indigo': [75, 0, 130, 1],\n  'ivory': [255, 255, 240, 1],\n  'khaki': [240, 230, 140, 1],\n  'lavender': [230, 230, 250, 1],\n  'lavenderblush': [255, 240, 245, 1],\n  'lawngreen': [124, 252, 0, 1],\n  'lemonchiffon': [255, 250, 205, 1],\n  'lightblue': [173, 216, 230, 1],\n  'lightcoral': [240, 128, 128, 1],\n  'lightcyan': [224, 255, 255, 1],\n  'lightgoldenrodyellow': [250, 250, 210, 1],\n  'lightgray': [211, 211, 211, 1],\n  'lightgreen': [144, 238, 144, 1],\n  'lightgrey': [211, 211, 211, 1],\n  'lightpink': [255, 182, 193, 1],\n  'lightsalmon': [255, 160, 122, 1],\n  'lightseagreen': [32, 178, 170, 1],\n  'lightskyblue': [135, 206, 250, 1],\n  'lightslategray': [119, 136, 153, 1],\n  'lightslategrey': [119, 136, 153, 1],\n  'lightsteelblue': [176, 196, 222, 1],\n  'lightyellow': [255, 255, 224, 1],\n  'lime': [0, 255, 0, 1],\n  'limegreen': [50, 205, 50, 1],\n  'linen': [250, 240, 230, 1],\n  'magenta': [255, 0, 255, 1],\n  'maroon': [128, 0, 0, 1],\n  'mediumaquamarine': [102, 205, 170, 1],\n  'mediumblue': [0, 0, 205, 1],\n  'mediumorchid': [186, 85, 211, 1],\n  'mediumpurple': [147, 112, 219, 1],\n  'mediumseagreen': [60, 179, 113, 1],\n  'mediumslateblue': [123, 104, 238, 1],\n  'mediumspringgreen': [0, 250, 154, 1],\n  'mediumturquoise': [72, 209, 204, 1],\n  'mediumvioletred': [199, 21, 133, 1],\n  'midnightblue': [25, 25, 112, 1],\n  'mintcream': [245, 255, 250, 1],\n  'mistyrose': [255, 228, 225, 1],\n  'moccasin': [255, 228, 181, 1],\n  'navajowhite': [255, 222, 173, 1],\n  'navy': [0, 0, 128, 1],\n  'oldlace': [253, 245, 230, 1],\n  'olive': [128, 128, 0, 1],\n  'olivedrab': [107, 142, 35, 1],\n  'orange': [255, 165, 0, 1],\n  'orangered': [255, 69, 0, 1],\n  'orchid': [218, 112, 214, 1],\n  'palegoldenrod': [238, 232, 170, 1],\n  'palegreen': [152, 251, 152, 1],\n  'paleturquoise': [175, 238, 238, 1],\n  'palevioletred': [219, 112, 147, 1],\n  'papayawhip': [255, 239, 213, 1],\n  'peachpuff': [255, 218, 185, 1],\n  'peru': [205, 133, 63, 1],\n  'pink': [255, 192, 203, 1],\n  'plum': [221, 160, 221, 1],\n  'powderblue': [176, 224, 230, 1],\n  'purple': [128, 0, 128, 1],\n  'red': [255, 0, 0, 1],\n  'rosybrown': [188, 143, 143, 1],\n  'royalblue': [65, 105, 225, 1],\n  'saddlebrown': [139, 69, 19, 1],\n  'salmon': [250, 128, 114, 1],\n  'sandybrown': [244, 164, 96, 1],\n  'seagreen': [46, 139, 87, 1],\n  'seashell': [255, 245, 238, 1],\n  'sienna': [160, 82, 45, 1],\n  'silver': [192, 192, 192, 1],\n  'skyblue': [135, 206, 235, 1],\n  'slateblue': [106, 90, 205, 1],\n  'slategray': [112, 128, 144, 1],\n  'slategrey': [112, 128, 144, 1],\n  'snow': [255, 250, 250, 1],\n  'springgreen': [0, 255, 127, 1],\n  'steelblue': [70, 130, 180, 1],\n  'tan': [210, 180, 140, 1],\n  'teal': [0, 128, 128, 1],\n  'thistle': [216, 191, 216, 1],\n  'tomato': [255, 99, 71, 1],\n  'turquoise': [64, 224, 208, 1],\n  'violet': [238, 130, 238, 1],\n  'wheat': [245, 222, 179, 1],\n  'white': [255, 255, 255, 1],\n  'whitesmoke': [245, 245, 245, 1],\n  'yellow': [255, 255, 0, 1],\n  'yellowgreen': [154, 205, 50, 1]\n};\n\nfunction clampCssByte(i) {\n  // Clamp to integer 0 .. 255.\n  i = Math.round(i); // Seems to be what Chrome does (vs truncation).\n\n  return i < 0 ? 0 : i > 255 ? 255 : i;\n}\n\nfunction clampCssAngle(i) {\n  // Clamp to integer 0 .. 360.\n  i = Math.round(i); // Seems to be what Chrome does (vs truncation).\n\n  return i < 0 ? 0 : i > 360 ? 360 : i;\n}\n\nfunction clampCssFloat(f) {\n  // Clamp to float 0.0 .. 1.0.\n  return f < 0 ? 0 : f > 1 ? 1 : f;\n}\n\nfunction parseCssInt(str) {\n  // int or percentage.\n  if (str.length && str.charAt(str.length - 1) === '%') {\n    return clampCssByte(parseFloat(str) / 100 * 255);\n  }\n\n  return clampCssByte(parseInt(str, 10));\n}\n\nfunction parseCssFloat(str) {\n  // float or percentage.\n  if (str.length && str.charAt(str.length - 1) === '%') {\n    return clampCssFloat(parseFloat(str) / 100);\n  }\n\n  return clampCssFloat(parseFloat(str));\n}\n\nfunction cssHueToRgb(m1, m2, h) {\n  if (h < 0) {\n    h += 1;\n  } else if (h > 1) {\n    h -= 1;\n  }\n\n  if (h * 6 < 1) {\n    return m1 + (m2 - m1) * h * 6;\n  }\n\n  if (h * 2 < 1) {\n    return m2;\n  }\n\n  if (h * 3 < 2) {\n    return m1 + (m2 - m1) * (2 / 3 - h) * 6;\n  }\n\n  return m1;\n}\n\nfunction lerpNumber(a, b, p) {\n  return a + (b - a) * p;\n}\n\nfunction setRgba(out, r, g, b, a) {\n  out[0] = r;\n  out[1] = g;\n  out[2] = b;\n  out[3] = a;\n  return out;\n}\n\nfunction copyRgba(out, a) {\n  out[0] = a[0];\n  out[1] = a[1];\n  out[2] = a[2];\n  out[3] = a[3];\n  return out;\n}\n\nvar colorCache = new LRU(20);\nvar lastRemovedArr = null;\n\nfunction putToCache(colorStr, rgbaArr) {\n  // Reuse removed array\n  if (lastRemovedArr) {\n    copyRgba(lastRemovedArr, rgbaArr);\n  }\n\n  lastRemovedArr = colorCache.put(colorStr, lastRemovedArr || rgbaArr.slice());\n}\n/**\n * @param {string} colorStr\n * @param {Array.<number>} out\n * @return {Array.<number>}\n * @memberOf module:zrender/util/color\n */\n\n\nfunction parse(colorStr, rgbaArr) {\n  if (!colorStr) {\n    return;\n  }\n\n  rgbaArr = rgbaArr || [];\n  var cached = colorCache.get(colorStr);\n\n  if (cached) {\n    return copyRgba(rgbaArr, cached);\n  } // colorStr may be not string\n\n\n  colorStr = colorStr + ''; // Remove all whitespace, not compliant, but should just be more accepting.\n\n  var str = colorStr.replace(/ /g, '').toLowerCase(); // Color keywords (and transparent) lookup.\n\n  if (str in kCSSColorTable) {\n    copyRgba(rgbaArr, kCSSColorTable[str]);\n    putToCache(colorStr, rgbaArr);\n    return rgbaArr;\n  } // #abc and #abc123 syntax.\n\n\n  if (str.charAt(0) === '#') {\n    if (str.length === 4) {\n      var iv = parseInt(str.substr(1), 16); // TODO(deanm): Stricter parsing.\n\n      if (!(iv >= 0 && iv <= 0xfff)) {\n        setRgba(rgbaArr, 0, 0, 0, 1);\n        return; // Covers NaN.\n      }\n\n      setRgba(rgbaArr, (iv & 0xf00) >> 4 | (iv & 0xf00) >> 8, iv & 0xf0 | (iv & 0xf0) >> 4, iv & 0xf | (iv & 0xf) << 4, 1);\n      putToCache(colorStr, rgbaArr);\n      return rgbaArr;\n    } else if (str.length === 7) {\n      var iv = parseInt(str.substr(1), 16); // TODO(deanm): Stricter parsing.\n\n      if (!(iv >= 0 && iv <= 0xffffff)) {\n        setRgba(rgbaArr, 0, 0, 0, 1);\n        return; // Covers NaN.\n      }\n\n      setRgba(rgbaArr, (iv & 0xff0000) >> 16, (iv & 0xff00) >> 8, iv & 0xff, 1);\n      putToCache(colorStr, rgbaArr);\n      return rgbaArr;\n    }\n\n    return;\n  }\n\n  var op = str.indexOf('(');\n  var ep = str.indexOf(')');\n\n  if (op !== -1 && ep + 1 === str.length) {\n    var fname = str.substr(0, op);\n    var params = str.substr(op + 1, ep - (op + 1)).split(',');\n    var alpha = 1; // To allow case fallthrough.\n\n    switch (fname) {\n      case 'rgba':\n        if (params.length !== 4) {\n          setRgba(rgbaArr, 0, 0, 0, 1);\n          return;\n        }\n\n        alpha = parseCssFloat(params.pop());\n      // jshint ignore:line\n      // Fall through.\n\n      case 'rgb':\n        if (params.length !== 3) {\n          setRgba(rgbaArr, 0, 0, 0, 1);\n          return;\n        }\n\n        setRgba(rgbaArr, parseCssInt(params[0]), parseCssInt(params[1]), parseCssInt(params[2]), alpha);\n        putToCache(colorStr, rgbaArr);\n        return rgbaArr;\n\n      case 'hsla':\n        if (params.length !== 4) {\n          setRgba(rgbaArr, 0, 0, 0, 1);\n          return;\n        }\n\n        params[3] = parseCssFloat(params[3]);\n        hsla2rgba(params, rgbaArr);\n        putToCache(colorStr, rgbaArr);\n        return rgbaArr;\n\n      case 'hsl':\n        if (params.length !== 3) {\n          setRgba(rgbaArr, 0, 0, 0, 1);\n          return;\n        }\n\n        hsla2rgba(params, rgbaArr);\n        putToCache(colorStr, rgbaArr);\n        return rgbaArr;\n\n      default:\n        return;\n    }\n  }\n\n  setRgba(rgbaArr, 0, 0, 0, 1);\n  return;\n}\n/**\n * @param {Array.<number>} hsla\n * @param {Array.<number>} rgba\n * @return {Array.<number>} rgba\n */\n\n\nfunction hsla2rgba(hsla, rgba) {\n  var h = (parseFloat(hsla[0]) % 360 + 360) % 360 / 360; // 0 .. 1\n  // NOTE(deanm): According to the CSS spec s/l should only be\n  // percentages, but we don't bother and let float or percentage.\n\n  var s = parseCssFloat(hsla[1]);\n  var l = parseCssFloat(hsla[2]);\n  var m2 = l <= 0.5 ? l * (s + 1) : l + s - l * s;\n  var m1 = l * 2 - m2;\n  rgba = rgba || [];\n  setRgba(rgba, clampCssByte(cssHueToRgb(m1, m2, h + 1 / 3) * 255), clampCssByte(cssHueToRgb(m1, m2, h) * 255), clampCssByte(cssHueToRgb(m1, m2, h - 1 / 3) * 255), 1);\n\n  if (hsla.length === 4) {\n    rgba[3] = hsla[3];\n  }\n\n  return rgba;\n}\n/**\n * @param {Array.<number>} rgba\n * @return {Array.<number>} hsla\n */\n\n\nfunction rgba2hsla(rgba) {\n  if (!rgba) {\n    return;\n  } // RGB from 0 to 255\n\n\n  var R = rgba[0] / 255;\n  var G = rgba[1] / 255;\n  var B = rgba[2] / 255;\n  var vMin = Math.min(R, G, B); // Min. value of RGB\n\n  var vMax = Math.max(R, G, B); // Max. value of RGB\n\n  var delta = vMax - vMin; // Delta RGB value\n\n  var L = (vMax + vMin) / 2;\n  var H;\n  var S; // HSL results from 0 to 1\n\n  if (delta === 0) {\n    H = 0;\n    S = 0;\n  } else {\n    if (L < 0.5) {\n      S = delta / (vMax + vMin);\n    } else {\n      S = delta / (2 - vMax - vMin);\n    }\n\n    var deltaR = ((vMax - R) / 6 + delta / 2) / delta;\n    var deltaG = ((vMax - G) / 6 + delta / 2) / delta;\n    var deltaB = ((vMax - B) / 6 + delta / 2) / delta;\n\n    if (R === vMax) {\n      H = deltaB - deltaG;\n    } else if (G === vMax) {\n      H = 1 / 3 + deltaR - deltaB;\n    } else if (B === vMax) {\n      H = 2 / 3 + deltaG - deltaR;\n    }\n\n    if (H < 0) {\n      H += 1;\n    }\n\n    if (H > 1) {\n      H -= 1;\n    }\n  }\n\n  var hsla = [H * 360, S, L];\n\n  if (rgba[3] != null) {\n    hsla.push(rgba[3]);\n  }\n\n  return hsla;\n}\n/**\n * @param {string} color\n * @param {number} level\n * @return {string}\n * @memberOf module:zrender/util/color\n */\n\n\nfunction lift(color, level) {\n  var colorArr = parse(color);\n\n  if (colorArr) {\n    for (var i = 0; i < 3; i++) {\n      if (level < 0) {\n        colorArr[i] = colorArr[i] * (1 - level) | 0;\n      } else {\n        colorArr[i] = (255 - colorArr[i]) * level + colorArr[i] | 0;\n      }\n\n      if (colorArr[i] > 255) {\n        colorArr[i] = 255;\n      } else if (color[i] < 0) {\n        colorArr[i] = 0;\n      }\n    }\n\n    return stringify(colorArr, colorArr.length === 4 ? 'rgba' : 'rgb');\n  }\n}\n/**\n * @param {string} color\n * @return {string}\n * @memberOf module:zrender/util/color\n */\n\n\nfunction toHex(color) {\n  var colorArr = parse(color);\n\n  if (colorArr) {\n    return ((1 << 24) + (colorArr[0] << 16) + (colorArr[1] << 8) + +colorArr[2]).toString(16).slice(1);\n  }\n}\n/**\n * Map value to color. Faster than lerp methods because color is represented by rgba array.\n * @param {number} normalizedValue A float between 0 and 1.\n * @param {Array.<Array.<number>>} colors List of rgba color array\n * @param {Array.<number>} [out] Mapped gba color array\n * @return {Array.<number>} will be null/undefined if input illegal.\n */\n\n\nfunction fastLerp(normalizedValue, colors, out) {\n  if (!(colors && colors.length) || !(normalizedValue >= 0 && normalizedValue <= 1)) {\n    return;\n  }\n\n  out = out || [];\n  var value = normalizedValue * (colors.length - 1);\n  var leftIndex = Math.floor(value);\n  var rightIndex = Math.ceil(value);\n  var leftColor = colors[leftIndex];\n  var rightColor = colors[rightIndex];\n  var dv = value - leftIndex;\n  out[0] = clampCssByte(lerpNumber(leftColor[0], rightColor[0], dv));\n  out[1] = clampCssByte(lerpNumber(leftColor[1], rightColor[1], dv));\n  out[2] = clampCssByte(lerpNumber(leftColor[2], rightColor[2], dv));\n  out[3] = clampCssFloat(lerpNumber(leftColor[3], rightColor[3], dv));\n  return out;\n}\n/**\n * @deprecated\n */\n\n\nvar fastMapToColor = fastLerp;\n/**\n * @param {number} normalizedValue A float between 0 and 1.\n * @param {Array.<string>} colors Color list.\n * @param {boolean=} fullOutput Default false.\n * @return {(string|Object)} Result color. If fullOutput,\n *                           return {color: ..., leftIndex: ..., rightIndex: ..., value: ...},\n * @memberOf module:zrender/util/color\n */\n\nfunction lerp(normalizedValue, colors, fullOutput) {\n  if (!(colors && colors.length) || !(normalizedValue >= 0 && normalizedValue <= 1)) {\n    return;\n  }\n\n  var value = normalizedValue * (colors.length - 1);\n  var leftIndex = Math.floor(value);\n  var rightIndex = Math.ceil(value);\n  var leftColor = parse(colors[leftIndex]);\n  var rightColor = parse(colors[rightIndex]);\n  var dv = value - leftIndex;\n  var color = stringify([clampCssByte(lerpNumber(leftColor[0], rightColor[0], dv)), clampCssByte(lerpNumber(leftColor[1], rightColor[1], dv)), clampCssByte(lerpNumber(leftColor[2], rightColor[2], dv)), clampCssFloat(lerpNumber(leftColor[3], rightColor[3], dv))], 'rgba');\n  return fullOutput ? {\n    color: color,\n    leftIndex: leftIndex,\n    rightIndex: rightIndex,\n    value: value\n  } : color;\n}\n/**\n * @deprecated\n */\n\n\nvar mapToColor = lerp;\n/**\n * @param {string} color\n * @param {number=} h 0 ~ 360, ignore when null.\n * @param {number=} s 0 ~ 1, ignore when null.\n * @param {number=} l 0 ~ 1, ignore when null.\n * @return {string} Color string in rgba format.\n * @memberOf module:zrender/util/color\n */\n\nfunction modifyHSL(color, h, s, l) {\n  color = parse(color);\n\n  if (color) {\n    color = rgba2hsla(color);\n    h != null && (color[0] = clampCssAngle(h));\n    s != null && (color[1] = parseCssFloat(s));\n    l != null && (color[2] = parseCssFloat(l));\n    return stringify(hsla2rgba(color), 'rgba');\n  }\n}\n/**\n * @param {string} color\n * @param {number=} alpha 0 ~ 1\n * @return {string} Color string in rgba format.\n * @memberOf module:zrender/util/color\n */\n\n\nfunction modifyAlpha(color, alpha) {\n  color = parse(color);\n\n  if (color && alpha != null) {\n    color[3] = clampCssFloat(alpha);\n    return stringify(color, 'rgba');\n  }\n}\n/**\n * @param {Array.<number>} arrColor like [12,33,44,0.4]\n * @param {string} type 'rgba', 'hsva', ...\n * @return {string} Result color. (If input illegal, return undefined).\n */\n\n\nfunction stringify(arrColor, type) {\n  if (!arrColor || !arrColor.length) {\n    return;\n  }\n\n  var colorStr = arrColor[0] + ',' + arrColor[1] + ',' + arrColor[2];\n\n  if (type === 'rgba' || type === 'hsva' || type === 'hsla') {\n    colorStr += ',' + arrColor[3];\n  }\n\n  return type + '(' + colorStr + ')';\n}\n\nexports.parse = parse;\nexports.lift = lift;\nexports.toHex = toHex;\nexports.fastLerp = fastLerp;\nexports.fastMapToColor = fastMapToColor;\nexports.lerp = lerp;\nexports.mapToColor = mapToColor;\nexports.modifyHSL = modifyHSL;\nexports.modifyAlpha = modifyAlpha;\nexports.stringify = stringify;","// Simple LRU cache use doubly linked list\n// @module zrender/core/LRU\n\n/**\n * Simple double linked list. Compared with array, it has O(1) remove operation.\n * @constructor\n */\nvar LinkedList = function () {\n  /**\n   * @type {module:zrender/core/LRU~Entry}\n   */\n  this.head = null;\n  /**\n   * @type {module:zrender/core/LRU~Entry}\n   */\n\n  this.tail = null;\n  this._len = 0;\n};\n\nvar linkedListProto = LinkedList.prototype;\n/**\n * Insert a new value at the tail\n * @param  {} val\n * @return {module:zrender/core/LRU~Entry}\n */\n\nlinkedListProto.insert = function (val) {\n  var entry = new Entry(val);\n  this.insertEntry(entry);\n  return entry;\n};\n/**\n * Insert an entry at the tail\n * @param  {module:zrender/core/LRU~Entry} entry\n */\n\n\nlinkedListProto.insertEntry = function (entry) {\n  if (!this.head) {\n    this.head = this.tail = entry;\n  } else {\n    this.tail.next = entry;\n    entry.prev = this.tail;\n    entry.next = null;\n    this.tail = entry;\n  }\n\n  this._len++;\n};\n/**\n * Remove entry.\n * @param  {module:zrender/core/LRU~Entry} entry\n */\n\n\nlinkedListProto.remove = function (entry) {\n  var prev = entry.prev;\n  var next = entry.next;\n\n  if (prev) {\n    prev.next = next;\n  } else {\n    // Is head\n    this.head = next;\n  }\n\n  if (next) {\n    next.prev = prev;\n  } else {\n    // Is tail\n    this.tail = prev;\n  }\n\n  entry.next = entry.prev = null;\n  this._len--;\n};\n/**\n * @return {number}\n */\n\n\nlinkedListProto.len = function () {\n  return this._len;\n};\n/**\n * Clear list\n */\n\n\nlinkedListProto.clear = function () {\n  this.head = this.tail = null;\n  this._len = 0;\n};\n/**\n * @constructor\n * @param {} val\n */\n\n\nvar Entry = function (val) {\n  /**\n   * @type {}\n   */\n  this.value = val;\n  /**\n   * @type {module:zrender/core/LRU~Entry}\n   */\n\n  this.next;\n  /**\n   * @type {module:zrender/core/LRU~Entry}\n   */\n\n  this.prev;\n};\n/**\n * LRU Cache\n * @constructor\n * @alias module:zrender/core/LRU\n */\n\n\nvar LRU = function (maxSize) {\n  this._list = new LinkedList();\n  this._map = {};\n  this._maxSize = maxSize || 10;\n  this._lastRemovedEntry = null;\n};\n\nvar LRUProto = LRU.prototype;\n/**\n * @param  {string} key\n * @param  {} value\n * @return {} Removed value\n */\n\nLRUProto.put = function (key, value) {\n  var list = this._list;\n  var map = this._map;\n  var removed = null;\n\n  if (map[key] == null) {\n    var len = list.len(); // Reuse last removed entry\n\n    var entry = this._lastRemovedEntry;\n\n    if (len >= this._maxSize && len > 0) {\n      // Remove the least recently used\n      var leastUsedEntry = list.head;\n      list.remove(leastUsedEntry);\n      delete map[leastUsedEntry.key];\n      removed = leastUsedEntry.value;\n      this._lastRemovedEntry = leastUsedEntry;\n    }\n\n    if (entry) {\n      entry.value = value;\n    } else {\n      entry = new Entry(value);\n    }\n\n    entry.key = key;\n    list.insertEntry(entry);\n    map[key] = entry;\n  }\n\n  return removed;\n};\n/**\n * @param  {string} key\n * @return {}\n */\n\n\nLRUProto.get = function (key) {\n  var entry = this._map[key];\n  var list = this._list;\n\n  if (entry != null) {\n    // Put the latest used entry in the tail\n    if (entry !== list.tail) {\n      list.remove(entry);\n      list.insertEntry(entry);\n    }\n\n    return entry.value;\n  }\n};\n/**\n * Clear the cache\n */\n\n\nLRUProto.clear = function () {\n  this._list.clear();\n\n  this._map = {};\n};\n\nvar _default = LRU;\nmodule.exports = _default;","var dpr = 1; // If in browser environment\n\nif (typeof window !== 'undefined') {\n  dpr = Math.max(window.devicePixelRatio || 1, 1);\n}\n/**\n * config默认配置项\n * @exports zrender/config\n * @author Kener (@Kener-林峰, kener.linfeng@gmail.com)\n */\n\n/**\n * debug日志选项：catchBrushException为true下有效\n * 0 : 不生成debug数据，发布用\n * 1 : 异常抛出，调试用\n * 2 : 控制台输出，调试用\n */\n\n\nvar debugMode = 0; // retina 屏幕优化\n\nvar devicePixelRatio = dpr;\nexports.debugMode = debugMode;\nexports.devicePixelRatio = devicePixelRatio;","var _util = require(\"../../core/util\");\n\nvar retrieve2 = _util.retrieve2;\nvar retrieve3 = _util.retrieve3;\nvar each = _util.each;\nvar normalizeCssArray = _util.normalizeCssArray;\nvar isString = _util.isString;\nvar isObject = _util.isObject;\n\nvar textContain = require(\"../../contain/text\");\n\nvar roundRectHelper = require(\"./roundRect\");\n\nvar imageHelper = require(\"./image\");\n\nvar fixShadow = require(\"./fixShadow\");\n\nvar _constant = require(\"../constant\");\n\nvar ContextCachedBy = _constant.ContextCachedBy;\nvar WILL_BE_RESTORED = _constant.WILL_BE_RESTORED;\nvar DEFAULT_FONT = textContain.DEFAULT_FONT; // TODO: Have not support 'start', 'end' yet.\n\nvar VALID_TEXT_ALIGN = {\n  left: 1,\n  right: 1,\n  center: 1\n};\nvar VALID_TEXT_VERTICAL_ALIGN = {\n  top: 1,\n  bottom: 1,\n  middle: 1\n}; // Different from `STYLE_COMMON_PROPS` of `graphic/Style`,\n// the default value of shadowColor is `'transparent'`.\n\nvar SHADOW_STYLE_COMMON_PROPS = [['textShadowBlur', 'shadowBlur', 0], ['textShadowOffsetX', 'shadowOffsetX', 0], ['textShadowOffsetY', 'shadowOffsetY', 0], ['textShadowColor', 'shadowColor', 'transparent']];\n/**\n * @param {module:zrender/graphic/Style} style\n * @return {module:zrender/graphic/Style} The input style.\n */\n\nfunction normalizeTextStyle(style) {\n  normalizeStyle(style);\n  each(style.rich, normalizeStyle);\n  return style;\n}\n\nfunction normalizeStyle(style) {\n  if (style) {\n    style.font = textContain.makeFont(style);\n    var textAlign = style.textAlign;\n    textAlign === 'middle' && (textAlign = 'center');\n    style.textAlign = textAlign == null || VALID_TEXT_ALIGN[textAlign] ? textAlign : 'left'; // Compatible with textBaseline.\n\n    var textVerticalAlign = style.textVerticalAlign || style.textBaseline;\n    textVerticalAlign === 'center' && (textVerticalAlign = 'middle');\n    style.textVerticalAlign = textVerticalAlign == null || VALID_TEXT_VERTICAL_ALIGN[textVerticalAlign] ? textVerticalAlign : 'top';\n    var textPadding = style.textPadding;\n\n    if (textPadding) {\n      style.textPadding = normalizeCssArray(style.textPadding);\n    }\n  }\n}\n/**\n * @param {CanvasRenderingContext2D} ctx\n * @param {string} text\n * @param {module:zrender/graphic/Style} style\n * @param {Object|boolean} [rect] {x, y, width, height}\n *                  If set false, rect text is not used.\n * @param {Element|module:zrender/graphic/helper/constant.WILL_BE_RESTORED} [prevEl] For ctx prop cache.\n */\n\n\nfunction renderText(hostEl, ctx, text, style, rect, prevEl) {\n  style.rich ? renderRichText(hostEl, ctx, text, style, rect, prevEl) : renderPlainText(hostEl, ctx, text, style, rect, prevEl);\n} // Avoid setting to ctx according to prevEl if possible for\n// performance in scenarios of large amount text.\n\n\nfunction renderPlainText(hostEl, ctx, text, style, rect, prevEl) {\n  'use strict';\n\n  var needDrawBg = needDrawBackground(style);\n  var prevStyle;\n  var checkCache = false;\n  var cachedByMe = ctx.__attrCachedBy === ContextCachedBy.PLAIN_TEXT; // Only take and check cache for `Text` el, but not RectText.\n\n  if (prevEl !== WILL_BE_RESTORED) {\n    if (prevEl) {\n      prevStyle = prevEl.style;\n      checkCache = !needDrawBg && cachedByMe && prevStyle;\n    } // Prevent from using cache in `Style::bind`, because of the case:\n    // ctx property is modified by other properties than `Style::bind`\n    // used, and Style::bind is called next.\n\n\n    ctx.__attrCachedBy = needDrawBg ? ContextCachedBy.NONE : ContextCachedBy.PLAIN_TEXT;\n  } // Since this will be restored, prevent from using these props to check cache in the next\n  // entering of this method. But do not need to clear other cache like `Style::bind`.\n  else if (cachedByMe) {\n      ctx.__attrCachedBy = ContextCachedBy.NONE;\n    }\n\n  var styleFont = style.font || DEFAULT_FONT; // PENDING\n  // Only `Text` el set `font` and keep it (`RectText` will restore). So theoretically\n  // we can make font cache on ctx, which can cache for text el that are discontinuous.\n  // But layer save/restore needed to be considered.\n  // if (styleFont !== ctx.__fontCache) {\n  //     ctx.font = styleFont;\n  //     if (prevEl !== WILL_BE_RESTORED) {\n  //         ctx.__fontCache = styleFont;\n  //     }\n  // }\n\n  if (!checkCache || styleFont !== (prevStyle.font || DEFAULT_FONT)) {\n    ctx.font = styleFont;\n  } // Use the final font from context-2d, because the final\n  // font might not be the style.font when it is illegal.\n  // But get `ctx.font` might be time consuming.\n\n\n  var computedFont = hostEl.__computedFont;\n\n  if (hostEl.__styleFont !== styleFont) {\n    hostEl.__styleFont = styleFont;\n    computedFont = hostEl.__computedFont = ctx.font;\n  }\n\n  var textPadding = style.textPadding;\n  var textLineHeight = style.textLineHeight;\n  var contentBlock = hostEl.__textCotentBlock;\n\n  if (!contentBlock || hostEl.__dirtyText) {\n    contentBlock = hostEl.__textCotentBlock = textContain.parsePlainText(text, computedFont, textPadding, textLineHeight, style.truncate);\n  }\n\n  var outerHeight = contentBlock.outerHeight;\n  var textLines = contentBlock.lines;\n  var lineHeight = contentBlock.lineHeight;\n  var boxPos = getBoxPosition(outerHeight, style, rect);\n  var baseX = boxPos.baseX;\n  var baseY = boxPos.baseY;\n  var textAlign = boxPos.textAlign || 'left';\n  var textVerticalAlign = boxPos.textVerticalAlign; // Origin of textRotation should be the base point of text drawing.\n\n  applyTextRotation(ctx, style, rect, baseX, baseY);\n  var boxY = textContain.adjustTextY(baseY, outerHeight, textVerticalAlign);\n  var textX = baseX;\n  var textY = boxY;\n\n  if (needDrawBg || textPadding) {\n    // Consider performance, do not call getTextWidth util necessary.\n    var textWidth = textContain.getWidth(text, computedFont);\n    var outerWidth = textWidth;\n    textPadding && (outerWidth += textPadding[1] + textPadding[3]);\n    var boxX = textContain.adjustTextX(baseX, outerWidth, textAlign);\n    needDrawBg && drawBackground(hostEl, ctx, style, boxX, boxY, outerWidth, outerHeight);\n\n    if (textPadding) {\n      textX = getTextXForPadding(baseX, textAlign, textPadding);\n      textY += textPadding[0];\n    }\n  } // Always set textAlign and textBase line, because it is difficute to calculate\n  // textAlign from prevEl, and we dont sure whether textAlign will be reset if\n  // font set happened.\n\n\n  ctx.textAlign = textAlign; // Force baseline to be \"middle\". Otherwise, if using \"top\", the\n  // text will offset downward a little bit in font \"Microsoft YaHei\".\n\n  ctx.textBaseline = 'middle'; // Set text opacity\n\n  ctx.globalAlpha = style.opacity || 1; // Always set shadowBlur and shadowOffset to avoid leak from displayable.\n\n  for (var i = 0; i < SHADOW_STYLE_COMMON_PROPS.length; i++) {\n    var propItem = SHADOW_STYLE_COMMON_PROPS[i];\n    var styleProp = propItem[0];\n    var ctxProp = propItem[1];\n    var val = style[styleProp];\n\n    if (!checkCache || val !== prevStyle[styleProp]) {\n      ctx[ctxProp] = fixShadow(ctx, ctxProp, val || propItem[2]);\n    }\n  } // `textBaseline` is set as 'middle'.\n\n\n  textY += lineHeight / 2;\n  var textStrokeWidth = style.textStrokeWidth;\n  var textStrokeWidthPrev = checkCache ? prevStyle.textStrokeWidth : null;\n  var strokeWidthChanged = !checkCache || textStrokeWidth !== textStrokeWidthPrev;\n  var strokeChanged = !checkCache || strokeWidthChanged || style.textStroke !== prevStyle.textStroke;\n  var textStroke = getStroke(style.textStroke, textStrokeWidth);\n  var textFill = getFill(style.textFill);\n\n  if (textStroke) {\n    if (strokeWidthChanged) {\n      ctx.lineWidth = textStrokeWidth;\n    }\n\n    if (strokeChanged) {\n      ctx.strokeStyle = textStroke;\n    }\n  }\n\n  if (textFill) {\n    if (!checkCache || style.textFill !== prevStyle.textFill) {\n      ctx.fillStyle = textFill;\n    }\n  } // Optimize simply, in most cases only one line exists.\n\n\n  if (textLines.length === 1) {\n    // Fill after stroke so the outline will not cover the main part.\n    textStroke && ctx.strokeText(textLines[0], textX, textY);\n    textFill && ctx.fillText(textLines[0], textX, textY);\n  } else {\n    for (var i = 0; i < textLines.length; i++) {\n      // Fill after stroke so the outline will not cover the main part.\n      textStroke && ctx.strokeText(textLines[i], textX, textY);\n      textFill && ctx.fillText(textLines[i], textX, textY);\n      textY += lineHeight;\n    }\n  }\n}\n\nfunction renderRichText(hostEl, ctx, text, style, rect, prevEl) {\n  // Do not do cache for rich text because of the complexity.\n  // But `RectText` this will be restored, do not need to clear other cache like `Style::bind`.\n  if (prevEl !== WILL_BE_RESTORED) {\n    ctx.__attrCachedBy = ContextCachedBy.NONE;\n  }\n\n  var contentBlock = hostEl.__textCotentBlock;\n\n  if (!contentBlock || hostEl.__dirtyText) {\n    contentBlock = hostEl.__textCotentBlock = textContain.parseRichText(text, style);\n  }\n\n  drawRichText(hostEl, ctx, contentBlock, style, rect);\n}\n\nfunction drawRichText(hostEl, ctx, contentBlock, style, rect) {\n  var contentWidth = contentBlock.width;\n  var outerWidth = contentBlock.outerWidth;\n  var outerHeight = contentBlock.outerHeight;\n  var textPadding = style.textPadding;\n  var boxPos = getBoxPosition(outerHeight, style, rect);\n  var baseX = boxPos.baseX;\n  var baseY = boxPos.baseY;\n  var textAlign = boxPos.textAlign;\n  var textVerticalAlign = boxPos.textVerticalAlign; // Origin of textRotation should be the base point of text drawing.\n\n  applyTextRotation(ctx, style, rect, baseX, baseY);\n  var boxX = textContain.adjustTextX(baseX, outerWidth, textAlign);\n  var boxY = textContain.adjustTextY(baseY, outerHeight, textVerticalAlign);\n  var xLeft = boxX;\n  var lineTop = boxY;\n\n  if (textPadding) {\n    xLeft += textPadding[3];\n    lineTop += textPadding[0];\n  }\n\n  var xRight = xLeft + contentWidth;\n  needDrawBackground(style) && drawBackground(hostEl, ctx, style, boxX, boxY, outerWidth, outerHeight);\n\n  for (var i = 0; i < contentBlock.lines.length; i++) {\n    var line = contentBlock.lines[i];\n    var tokens = line.tokens;\n    var tokenCount = tokens.length;\n    var lineHeight = line.lineHeight;\n    var usedWidth = line.width;\n    var leftIndex = 0;\n    var lineXLeft = xLeft;\n    var lineXRight = xRight;\n    var rightIndex = tokenCount - 1;\n    var token;\n\n    while (leftIndex < tokenCount && (token = tokens[leftIndex], !token.textAlign || token.textAlign === 'left')) {\n      placeToken(hostEl, ctx, token, style, lineHeight, lineTop, lineXLeft, 'left');\n      usedWidth -= token.width;\n      lineXLeft += token.width;\n      leftIndex++;\n    }\n\n    while (rightIndex >= 0 && (token = tokens[rightIndex], token.textAlign === 'right')) {\n      placeToken(hostEl, ctx, token, style, lineHeight, lineTop, lineXRight, 'right');\n      usedWidth -= token.width;\n      lineXRight -= token.width;\n      rightIndex--;\n    } // The other tokens are placed as textAlign 'center' if there is enough space.\n\n\n    lineXLeft += (contentWidth - (lineXLeft - xLeft) - (xRight - lineXRight) - usedWidth) / 2;\n\n    while (leftIndex <= rightIndex) {\n      token = tokens[leftIndex]; // Consider width specified by user, use 'center' rather than 'left'.\n\n      placeToken(hostEl, ctx, token, style, lineHeight, lineTop, lineXLeft + token.width / 2, 'center');\n      lineXLeft += token.width;\n      leftIndex++;\n    }\n\n    lineTop += lineHeight;\n  }\n}\n\nfunction applyTextRotation(ctx, style, rect, x, y) {\n  // textRotation only apply in RectText.\n  if (rect && style.textRotation) {\n    var origin = style.textOrigin;\n\n    if (origin === 'center') {\n      x = rect.width / 2 + rect.x;\n      y = rect.height / 2 + rect.y;\n    } else if (origin) {\n      x = origin[0] + rect.x;\n      y = origin[1] + rect.y;\n    }\n\n    ctx.translate(x, y); // Positive: anticlockwise\n\n    ctx.rotate(-style.textRotation);\n    ctx.translate(-x, -y);\n  }\n}\n\nfunction placeToken(hostEl, ctx, token, style, lineHeight, lineTop, x, textAlign) {\n  var tokenStyle = style.rich[token.styleName] || {};\n  tokenStyle.text = token.text; // 'ctx.textBaseline' is always set as 'middle', for sake of\n  // the bias of \"Microsoft YaHei\".\n\n  var textVerticalAlign = token.textVerticalAlign;\n  var y = lineTop + lineHeight / 2;\n\n  if (textVerticalAlign === 'top') {\n    y = lineTop + token.height / 2;\n  } else if (textVerticalAlign === 'bottom') {\n    y = lineTop + lineHeight - token.height / 2;\n  }\n\n  !token.isLineHolder && needDrawBackground(tokenStyle) && drawBackground(hostEl, ctx, tokenStyle, textAlign === 'right' ? x - token.width : textAlign === 'center' ? x - token.width / 2 : x, y - token.height / 2, token.width, token.height);\n  var textPadding = token.textPadding;\n\n  if (textPadding) {\n    x = getTextXForPadding(x, textAlign, textPadding);\n    y -= token.height / 2 - textPadding[2] - token.textHeight / 2;\n  }\n\n  setCtx(ctx, 'shadowBlur', retrieve3(tokenStyle.textShadowBlur, style.textShadowBlur, 0));\n  setCtx(ctx, 'shadowColor', tokenStyle.textShadowColor || style.textShadowColor || 'transparent');\n  setCtx(ctx, 'shadowOffsetX', retrieve3(tokenStyle.textShadowOffsetX, style.textShadowOffsetX, 0));\n  setCtx(ctx, 'shadowOffsetY', retrieve3(tokenStyle.textShadowOffsetY, style.textShadowOffsetY, 0));\n  setCtx(ctx, 'textAlign', textAlign); // Force baseline to be \"middle\". Otherwise, if using \"top\", the\n  // text will offset downward a little bit in font \"Microsoft YaHei\".\n\n  setCtx(ctx, 'textBaseline', 'middle');\n  setCtx(ctx, 'font', token.font || DEFAULT_FONT);\n  var textStroke = getStroke(tokenStyle.textStroke || style.textStroke, textStrokeWidth);\n  var textFill = getFill(tokenStyle.textFill || style.textFill);\n  var textStrokeWidth = retrieve2(tokenStyle.textStrokeWidth, style.textStrokeWidth); // Fill after stroke so the outline will not cover the main part.\n\n  if (textStroke) {\n    setCtx(ctx, 'lineWidth', textStrokeWidth);\n    setCtx(ctx, 'strokeStyle', textStroke);\n    ctx.strokeText(token.text, x, y);\n  }\n\n  if (textFill) {\n    setCtx(ctx, 'fillStyle', textFill);\n    ctx.fillText(token.text, x, y);\n  }\n}\n\nfunction needDrawBackground(style) {\n  return !!(style.textBackgroundColor || style.textBorderWidth && style.textBorderColor);\n} // style: {textBackgroundColor, textBorderWidth, textBorderColor, textBorderRadius, text}\n// shape: {x, y, width, height}\n\n\nfunction drawBackground(hostEl, ctx, style, x, y, width, height) {\n  var textBackgroundColor = style.textBackgroundColor;\n  var textBorderWidth = style.textBorderWidth;\n  var textBorderColor = style.textBorderColor;\n  var isPlainBg = isString(textBackgroundColor);\n  setCtx(ctx, 'shadowBlur', style.textBoxShadowBlur || 0);\n  setCtx(ctx, 'shadowColor', style.textBoxShadowColor || 'transparent');\n  setCtx(ctx, 'shadowOffsetX', style.textBoxShadowOffsetX || 0);\n  setCtx(ctx, 'shadowOffsetY', style.textBoxShadowOffsetY || 0);\n\n  if (isPlainBg || textBorderWidth && textBorderColor) {\n    ctx.beginPath();\n    var textBorderRadius = style.textBorderRadius;\n\n    if (!textBorderRadius) {\n      ctx.rect(x, y, width, height);\n    } else {\n      roundRectHelper.buildPath(ctx, {\n        x: x,\n        y: y,\n        width: width,\n        height: height,\n        r: textBorderRadius\n      });\n    }\n\n    ctx.closePath();\n  }\n\n  if (isPlainBg) {\n    setCtx(ctx, 'fillStyle', textBackgroundColor);\n\n    if (style.fillOpacity != null) {\n      var originalGlobalAlpha = ctx.globalAlpha;\n      ctx.globalAlpha = style.fillOpacity * style.opacity;\n      ctx.fill();\n      ctx.globalAlpha = originalGlobalAlpha;\n    } else {\n      ctx.fill();\n    }\n  } else if (isObject(textBackgroundColor)) {\n    var image = textBackgroundColor.image;\n    image = imageHelper.createOrUpdateImage(image, null, hostEl, onBgImageLoaded, textBackgroundColor);\n\n    if (image && imageHelper.isImageReady(image)) {\n      ctx.drawImage(image, x, y, width, height);\n    }\n  }\n\n  if (textBorderWidth && textBorderColor) {\n    setCtx(ctx, 'lineWidth', textBorderWidth);\n    setCtx(ctx, 'strokeStyle', textBorderColor);\n\n    if (style.strokeOpacity != null) {\n      var originalGlobalAlpha = ctx.globalAlpha;\n      ctx.globalAlpha = style.strokeOpacity * style.opacity;\n      ctx.stroke();\n      ctx.globalAlpha = originalGlobalAlpha;\n    } else {\n      ctx.stroke();\n    }\n  }\n}\n\nfunction onBgImageLoaded(image, textBackgroundColor) {\n  // Replace image, so that `contain/text.js#parseRichText`\n  // will get correct result in next tick.\n  textBackgroundColor.image = image;\n}\n\nfunction getBoxPosition(blockHeiht, style, rect) {\n  var baseX = style.x || 0;\n  var baseY = style.y || 0;\n  var textAlign = style.textAlign;\n  var textVerticalAlign = style.textVerticalAlign; // Text position represented by coord\n\n  if (rect) {\n    var textPosition = style.textPosition;\n\n    if (textPosition instanceof Array) {\n      // Percent\n      baseX = rect.x + parsePercent(textPosition[0], rect.width);\n      baseY = rect.y + parsePercent(textPosition[1], rect.height);\n    } else {\n      var res = textContain.adjustTextPositionOnRect(textPosition, rect, style.textDistance);\n      baseX = res.x;\n      baseY = res.y; // Default align and baseline when has textPosition\n\n      textAlign = textAlign || res.textAlign;\n      textVerticalAlign = textVerticalAlign || res.textVerticalAlign;\n    } // textOffset is only support in RectText, otherwise\n    // we have to adjust boundingRect for textOffset.\n\n\n    var textOffset = style.textOffset;\n\n    if (textOffset) {\n      baseX += textOffset[0];\n      baseY += textOffset[1];\n    }\n  }\n\n  return {\n    baseX: baseX,\n    baseY: baseY,\n    textAlign: textAlign,\n    textVerticalAlign: textVerticalAlign\n  };\n}\n\nfunction setCtx(ctx, prop, value) {\n  ctx[prop] = fixShadow(ctx, prop, value);\n  return ctx[prop];\n}\n/**\n * @param {string} [stroke] If specified, do not check style.textStroke.\n * @param {string} [lineWidth] If specified, do not check style.textStroke.\n * @param {number} style\n */\n\n\nfunction getStroke(stroke, lineWidth) {\n  return stroke == null || lineWidth <= 0 || stroke === 'transparent' || stroke === 'none' ? null // TODO pattern and gradient?\n  : stroke.image || stroke.colorStops ? '#000' : stroke;\n}\n\nfunction getFill(fill) {\n  return fill == null || fill === 'none' ? null // TODO pattern and gradient?\n  : fill.image || fill.colorStops ? '#000' : fill;\n}\n\nfunction parsePercent(value, maxValue) {\n  if (typeof value === 'string') {\n    if (value.lastIndexOf('%') >= 0) {\n      return parseFloat(value) / 100 * maxValue;\n    }\n\n    return parseFloat(value);\n  }\n\n  return value;\n}\n\nfunction getTextXForPadding(x, textAlign, textPadding) {\n  return textAlign === 'right' ? x - textPadding[1] : textAlign === 'center' ? x + textPadding[3] / 2 - textPadding[1] / 2 : x + textPadding[3];\n}\n/**\n * @param {string} text\n * @param {module:zrender/Style} style\n * @return {boolean}\n */\n\n\nfunction needDrawText(text, style) {\n  return text != null && (text || style.textBackgroundColor || style.textBorderWidth && style.textBorderColor || style.textPadding);\n}\n\nexports.normalizeTextStyle = normalizeTextStyle;\nexports.renderText = renderText;\nexports.getStroke = getStroke;\nexports.getFill = getFill;\nexports.needDrawText = needDrawText;","var BoundingRect = require(\"../core/BoundingRect\");\n\nvar imageHelper = require(\"../graphic/helper/image\");\n\nvar _util = require(\"../core/util\");\n\nvar getContext = _util.getContext;\nvar extend = _util.extend;\nvar retrieve2 = _util.retrieve2;\nvar retrieve3 = _util.retrieve3;\nvar trim = _util.trim;\nvar textWidthCache = {};\nvar textWidthCacheCounter = 0;\nvar TEXT_CACHE_MAX = 5000;\nvar STYLE_REG = /\\{([a-zA-Z0-9_]+)\\|([^}]*)\\}/g;\nvar DEFAULT_FONT = '12px sans-serif'; // Avoid assign to an exported variable, for transforming to cjs.\n\nvar methods = {};\n\nfunction $override(name, fn) {\n  methods[name] = fn;\n}\n/**\n * @public\n * @param {string} text\n * @param {string} font\n * @return {number} width\n */\n\n\nfunction getWidth(text, font) {\n  font = font || DEFAULT_FONT;\n  var key = text + ':' + font;\n\n  if (textWidthCache[key]) {\n    return textWidthCache[key];\n  }\n\n  var textLines = (text + '').split('\\n');\n  var width = 0;\n\n  for (var i = 0, l = textLines.length; i < l; i++) {\n    // textContain.measureText may be overrided in SVG or VML\n    width = Math.max(measureText(textLines[i], font).width, width);\n  }\n\n  if (textWidthCacheCounter > TEXT_CACHE_MAX) {\n    textWidthCacheCounter = 0;\n    textWidthCache = {};\n  }\n\n  textWidthCacheCounter++;\n  textWidthCache[key] = width;\n  return width;\n}\n/**\n * @public\n * @param {string} text\n * @param {string} font\n * @param {string} [textAlign='left']\n * @param {string} [textVerticalAlign='top']\n * @param {Array.<number>} [textPadding]\n * @param {Object} [rich]\n * @param {Object} [truncate]\n * @return {Object} {x, y, width, height, lineHeight}\n */\n\n\nfunction getBoundingRect(text, font, textAlign, textVerticalAlign, textPadding, textLineHeight, rich, truncate) {\n  return rich ? getRichTextRect(text, font, textAlign, textVerticalAlign, textPadding, textLineHeight, rich, truncate) : getPlainTextRect(text, font, textAlign, textVerticalAlign, textPadding, textLineHeight, truncate);\n}\n\nfunction getPlainTextRect(text, font, textAlign, textVerticalAlign, textPadding, textLineHeight, truncate) {\n  var contentBlock = parsePlainText(text, font, textPadding, textLineHeight, truncate);\n  var outerWidth = getWidth(text, font);\n\n  if (textPadding) {\n    outerWidth += textPadding[1] + textPadding[3];\n  }\n\n  var outerHeight = contentBlock.outerHeight;\n  var x = adjustTextX(0, outerWidth, textAlign);\n  var y = adjustTextY(0, outerHeight, textVerticalAlign);\n  var rect = new BoundingRect(x, y, outerWidth, outerHeight);\n  rect.lineHeight = contentBlock.lineHeight;\n  return rect;\n}\n\nfunction getRichTextRect(text, font, textAlign, textVerticalAlign, textPadding, textLineHeight, rich, truncate) {\n  var contentBlock = parseRichText(text, {\n    rich: rich,\n    truncate: truncate,\n    font: font,\n    textAlign: textAlign,\n    textPadding: textPadding,\n    textLineHeight: textLineHeight\n  });\n  var outerWidth = contentBlock.outerWidth;\n  var outerHeight = contentBlock.outerHeight;\n  var x = adjustTextX(0, outerWidth, textAlign);\n  var y = adjustTextY(0, outerHeight, textVerticalAlign);\n  return new BoundingRect(x, y, outerWidth, outerHeight);\n}\n/**\n * @public\n * @param {number} x\n * @param {number} width\n * @param {string} [textAlign='left']\n * @return {number} Adjusted x.\n */\n\n\nfunction adjustTextX(x, width, textAlign) {\n  // FIXME Right to left language\n  if (textAlign === 'right') {\n    x -= width;\n  } else if (textAlign === 'center') {\n    x -= width / 2;\n  }\n\n  return x;\n}\n/**\n * @public\n * @param {number} y\n * @param {number} height\n * @param {string} [textVerticalAlign='top']\n * @return {number} Adjusted y.\n */\n\n\nfunction adjustTextY(y, height, textVerticalAlign) {\n  if (textVerticalAlign === 'middle') {\n    y -= height / 2;\n  } else if (textVerticalAlign === 'bottom') {\n    y -= height;\n  }\n\n  return y;\n}\n/**\n * @public\n * @param {stirng} textPosition\n * @param {Object} rect {x, y, width, height}\n * @param {number} distance\n * @return {Object} {x, y, textAlign, textVerticalAlign}\n */\n\n\nfunction adjustTextPositionOnRect(textPosition, rect, distance) {\n  var x = rect.x;\n  var y = rect.y;\n  var height = rect.height;\n  var width = rect.width;\n  var halfHeight = height / 2;\n  var textAlign = 'left';\n  var textVerticalAlign = 'top';\n\n  switch (textPosition) {\n    case 'left':\n      x -= distance;\n      y += halfHeight;\n      textAlign = 'right';\n      textVerticalAlign = 'middle';\n      break;\n\n    case 'right':\n      x += distance + width;\n      y += halfHeight;\n      textVerticalAlign = 'middle';\n      break;\n\n    case 'top':\n      x += width / 2;\n      y -= distance;\n      textAlign = 'center';\n      textVerticalAlign = 'bottom';\n      break;\n\n    case 'bottom':\n      x += width / 2;\n      y += height + distance;\n      textAlign = 'center';\n      break;\n\n    case 'inside':\n      x += width / 2;\n      y += halfHeight;\n      textAlign = 'center';\n      textVerticalAlign = 'middle';\n      break;\n\n    case 'insideLeft':\n      x += distance;\n      y += halfHeight;\n      textVerticalAlign = 'middle';\n      break;\n\n    case 'insideRight':\n      x += width - distance;\n      y += halfHeight;\n      textAlign = 'right';\n      textVerticalAlign = 'middle';\n      break;\n\n    case 'insideTop':\n      x += width / 2;\n      y += distance;\n      textAlign = 'center';\n      break;\n\n    case 'insideBottom':\n      x += width / 2;\n      y += height - distance;\n      textAlign = 'center';\n      textVerticalAlign = 'bottom';\n      break;\n\n    case 'insideTopLeft':\n      x += distance;\n      y += distance;\n      break;\n\n    case 'insideTopRight':\n      x += width - distance;\n      y += distance;\n      textAlign = 'right';\n      break;\n\n    case 'insideBottomLeft':\n      x += distance;\n      y += height - distance;\n      textVerticalAlign = 'bottom';\n      break;\n\n    case 'insideBottomRight':\n      x += width - distance;\n      y += height - distance;\n      textAlign = 'right';\n      textVerticalAlign = 'bottom';\n      break;\n  }\n\n  return {\n    x: x,\n    y: y,\n    textAlign: textAlign,\n    textVerticalAlign: textVerticalAlign\n  };\n}\n/**\n * Show ellipsis if overflow.\n *\n * @public\n * @param  {string} text\n * @param  {string} containerWidth\n * @param  {string} font\n * @param  {number} [ellipsis='...']\n * @param  {Object} [options]\n * @param  {number} [options.maxIterations=3]\n * @param  {number} [options.minChar=0] If truncate result are less\n *                  then minChar, ellipsis will not show, which is\n *                  better for user hint in some cases.\n * @param  {number} [options.placeholder=''] When all truncated, use the placeholder.\n * @return {string}\n */\n\n\nfunction truncateText(text, containerWidth, font, ellipsis, options) {\n  if (!containerWidth) {\n    return '';\n  }\n\n  var textLines = (text + '').split('\\n');\n  options = prepareTruncateOptions(containerWidth, font, ellipsis, options); // FIXME\n  // It is not appropriate that every line has '...' when truncate multiple lines.\n\n  for (var i = 0, len = textLines.length; i < len; i++) {\n    textLines[i] = truncateSingleLine(textLines[i], options);\n  }\n\n  return textLines.join('\\n');\n}\n\nfunction prepareTruncateOptions(containerWidth, font, ellipsis, options) {\n  options = extend({}, options);\n  options.font = font;\n  var ellipsis = retrieve2(ellipsis, '...');\n  options.maxIterations = retrieve2(options.maxIterations, 2);\n  var minChar = options.minChar = retrieve2(options.minChar, 0); // FIXME\n  // Other languages?\n\n  options.cnCharWidth = getWidth('国', font); // FIXME\n  // Consider proportional font?\n\n  var ascCharWidth = options.ascCharWidth = getWidth('a', font);\n  options.placeholder = retrieve2(options.placeholder, ''); // Example 1: minChar: 3, text: 'asdfzxcv', truncate result: 'asdf', but not: 'a...'.\n  // Example 2: minChar: 3, text: '维度', truncate result: '维', but not: '...'.\n\n  var contentWidth = containerWidth = Math.max(0, containerWidth - 1); // Reserve some gap.\n\n  for (var i = 0; i < minChar && contentWidth >= ascCharWidth; i++) {\n    contentWidth -= ascCharWidth;\n  }\n\n  var ellipsisWidth = getWidth(ellipsis, font);\n\n  if (ellipsisWidth > contentWidth) {\n    ellipsis = '';\n    ellipsisWidth = 0;\n  }\n\n  contentWidth = containerWidth - ellipsisWidth;\n  options.ellipsis = ellipsis;\n  options.ellipsisWidth = ellipsisWidth;\n  options.contentWidth = contentWidth;\n  options.containerWidth = containerWidth;\n  return options;\n}\n\nfunction truncateSingleLine(textLine, options) {\n  var containerWidth = options.containerWidth;\n  var font = options.font;\n  var contentWidth = options.contentWidth;\n\n  if (!containerWidth) {\n    return '';\n  }\n\n  var lineWidth = getWidth(textLine, font);\n\n  if (lineWidth <= containerWidth) {\n    return textLine;\n  }\n\n  for (var j = 0;; j++) {\n    if (lineWidth <= contentWidth || j >= options.maxIterations) {\n      textLine += options.ellipsis;\n      break;\n    }\n\n    var subLength = j === 0 ? estimateLength(textLine, contentWidth, options.ascCharWidth, options.cnCharWidth) : lineWidth > 0 ? Math.floor(textLine.length * contentWidth / lineWidth) : 0;\n    textLine = textLine.substr(0, subLength);\n    lineWidth = getWidth(textLine, font);\n  }\n\n  if (textLine === '') {\n    textLine = options.placeholder;\n  }\n\n  return textLine;\n}\n\nfunction estimateLength(text, contentWidth, ascCharWidth, cnCharWidth) {\n  var width = 0;\n  var i = 0;\n\n  for (var len = text.length; i < len && width < contentWidth; i++) {\n    var charCode = text.charCodeAt(i);\n    width += 0 <= charCode && charCode <= 127 ? ascCharWidth : cnCharWidth;\n  }\n\n  return i;\n}\n/**\n * @public\n * @param {string} font\n * @return {number} line height\n */\n\n\nfunction getLineHeight(font) {\n  // FIXME A rough approach.\n  return getWidth('国', font);\n}\n/**\n * @public\n * @param {string} text\n * @param {string} font\n * @return {Object} width\n */\n\n\nfunction measureText(text, font) {\n  return methods.measureText(text, font);\n} // Avoid assign to an exported variable, for transforming to cjs.\n\n\nmethods.measureText = function (text, font) {\n  var ctx = getContext();\n  ctx.font = font || DEFAULT_FONT;\n  return ctx.measureText(text);\n};\n/**\n * @public\n * @param {string} text\n * @param {string} font\n * @param {Object} [truncate]\n * @return {Object} block: {lineHeight, lines, height, outerHeight}\n *  Notice: for performance, do not calculate outerWidth util needed.\n */\n\n\nfunction parsePlainText(text, font, padding, textLineHeight, truncate) {\n  text != null && (text += '');\n  var lineHeight = retrieve2(textLineHeight, getLineHeight(font));\n  var lines = text ? text.split('\\n') : [];\n  var height = lines.length * lineHeight;\n  var outerHeight = height;\n\n  if (padding) {\n    outerHeight += padding[0] + padding[2];\n  }\n\n  if (text && truncate) {\n    var truncOuterHeight = truncate.outerHeight;\n    var truncOuterWidth = truncate.outerWidth;\n\n    if (truncOuterHeight != null && outerHeight > truncOuterHeight) {\n      text = '';\n      lines = [];\n    } else if (truncOuterWidth != null) {\n      var options = prepareTruncateOptions(truncOuterWidth - (padding ? padding[1] + padding[3] : 0), font, truncate.ellipsis, {\n        minChar: truncate.minChar,\n        placeholder: truncate.placeholder\n      }); // FIXME\n      // It is not appropriate that every line has '...' when truncate multiple lines.\n\n      for (var i = 0, len = lines.length; i < len; i++) {\n        lines[i] = truncateSingleLine(lines[i], options);\n      }\n    }\n  }\n\n  return {\n    lines: lines,\n    height: height,\n    outerHeight: outerHeight,\n    lineHeight: lineHeight\n  };\n}\n/**\n * For example: 'some text {a|some text}other text{b|some text}xxx{c|}xxx'\n * Also consider 'bbbb{a|xxx\\nzzz}xxxx\\naaaa'.\n *\n * @public\n * @param {string} text\n * @param {Object} style\n * @return {Object} block\n * {\n *      width,\n *      height,\n *      lines: [{\n *          lineHeight,\n *          width,\n *          tokens: [[{\n *              styleName,\n *              text,\n *              width,      // include textPadding\n *              height,     // include textPadding\n *              textWidth, // pure text width\n *              textHeight, // pure text height\n *              lineHeihgt,\n *              font,\n *              textAlign,\n *              textVerticalAlign\n *          }], [...], ...]\n *      }, ...]\n * }\n * If styleName is undefined, it is plain text.\n */\n\n\nfunction parseRichText(text, style) {\n  var contentBlock = {\n    lines: [],\n    width: 0,\n    height: 0\n  };\n  text != null && (text += '');\n\n  if (!text) {\n    return contentBlock;\n  }\n\n  var lastIndex = STYLE_REG.lastIndex = 0;\n  var result;\n\n  while ((result = STYLE_REG.exec(text)) != null) {\n    var matchedIndex = result.index;\n\n    if (matchedIndex > lastIndex) {\n      pushTokens(contentBlock, text.substring(lastIndex, matchedIndex));\n    }\n\n    pushTokens(contentBlock, result[2], result[1]);\n    lastIndex = STYLE_REG.lastIndex;\n  }\n\n  if (lastIndex < text.length) {\n    pushTokens(contentBlock, text.substring(lastIndex, text.length));\n  }\n\n  var lines = contentBlock.lines;\n  var contentHeight = 0;\n  var contentWidth = 0; // For `textWidth: 100%`\n\n  var pendingList = [];\n  var stlPadding = style.textPadding;\n  var truncate = style.truncate;\n  var truncateWidth = truncate && truncate.outerWidth;\n  var truncateHeight = truncate && truncate.outerHeight;\n\n  if (stlPadding) {\n    truncateWidth != null && (truncateWidth -= stlPadding[1] + stlPadding[3]);\n    truncateHeight != null && (truncateHeight -= stlPadding[0] + stlPadding[2]);\n  } // Calculate layout info of tokens.\n\n\n  for (var i = 0; i < lines.length; i++) {\n    var line = lines[i];\n    var lineHeight = 0;\n    var lineWidth = 0;\n\n    for (var j = 0; j < line.tokens.length; j++) {\n      var token = line.tokens[j];\n      var tokenStyle = token.styleName && style.rich[token.styleName] || {}; // textPadding should not inherit from style.\n\n      var textPadding = token.textPadding = tokenStyle.textPadding; // textFont has been asigned to font by `normalizeStyle`.\n\n      var font = token.font = tokenStyle.font || style.font; // textHeight can be used when textVerticalAlign is specified in token.\n\n      var tokenHeight = token.textHeight = retrieve2( // textHeight should not be inherited, consider it can be specified\n      // as box height of the block.\n      tokenStyle.textHeight, getLineHeight(font));\n      textPadding && (tokenHeight += textPadding[0] + textPadding[2]);\n      token.height = tokenHeight;\n      token.lineHeight = retrieve3(tokenStyle.textLineHeight, style.textLineHeight, tokenHeight);\n      token.textAlign = tokenStyle && tokenStyle.textAlign || style.textAlign;\n      token.textVerticalAlign = tokenStyle && tokenStyle.textVerticalAlign || 'middle';\n\n      if (truncateHeight != null && contentHeight + token.lineHeight > truncateHeight) {\n        return {\n          lines: [],\n          width: 0,\n          height: 0\n        };\n      }\n\n      token.textWidth = getWidth(token.text, font);\n      var tokenWidth = tokenStyle.textWidth;\n      var tokenWidthNotSpecified = tokenWidth == null || tokenWidth === 'auto'; // Percent width, can be `100%`, can be used in drawing separate\n      // line when box width is needed to be auto.\n\n      if (typeof tokenWidth === 'string' && tokenWidth.charAt(tokenWidth.length - 1) === '%') {\n        token.percentWidth = tokenWidth;\n        pendingList.push(token);\n        tokenWidth = 0; // Do not truncate in this case, because there is no user case\n        // and it is too complicated.\n      } else {\n        if (tokenWidthNotSpecified) {\n          tokenWidth = token.textWidth; // FIXME: If image is not loaded and textWidth is not specified, calling\n          // `getBoundingRect()` will not get correct result.\n\n          var textBackgroundColor = tokenStyle.textBackgroundColor;\n          var bgImg = textBackgroundColor && textBackgroundColor.image; // Use cases:\n          // (1) If image is not loaded, it will be loaded at render phase and call\n          // `dirty()` and `textBackgroundColor.image` will be replaced with the loaded\n          // image, and then the right size will be calculated here at the next tick.\n          // See `graphic/helper/text.js`.\n          // (2) If image loaded, and `textBackgroundColor.image` is image src string,\n          // use `imageHelper.findExistImage` to find cached image.\n          // `imageHelper.findExistImage` will always be called here before\n          // `imageHelper.createOrUpdateImage` in `graphic/helper/text.js#renderRichText`\n          // which ensures that image will not be rendered before correct size calcualted.\n\n          if (bgImg) {\n            bgImg = imageHelper.findExistImage(bgImg);\n\n            if (imageHelper.isImageReady(bgImg)) {\n              tokenWidth = Math.max(tokenWidth, bgImg.width * tokenHeight / bgImg.height);\n            }\n          }\n        }\n\n        var paddingW = textPadding ? textPadding[1] + textPadding[3] : 0;\n        tokenWidth += paddingW;\n        var remianTruncWidth = truncateWidth != null ? truncateWidth - lineWidth : null;\n\n        if (remianTruncWidth != null && remianTruncWidth < tokenWidth) {\n          if (!tokenWidthNotSpecified || remianTruncWidth < paddingW) {\n            token.text = '';\n            token.textWidth = tokenWidth = 0;\n          } else {\n            token.text = truncateText(token.text, remianTruncWidth - paddingW, font, truncate.ellipsis, {\n              minChar: truncate.minChar\n            });\n            token.textWidth = getWidth(token.text, font);\n            tokenWidth = token.textWidth + paddingW;\n          }\n        }\n      }\n\n      lineWidth += token.width = tokenWidth;\n      tokenStyle && (lineHeight = Math.max(lineHeight, token.lineHeight));\n    }\n\n    line.width = lineWidth;\n    line.lineHeight = lineHeight;\n    contentHeight += lineHeight;\n    contentWidth = Math.max(contentWidth, lineWidth);\n  }\n\n  contentBlock.outerWidth = contentBlock.width = retrieve2(style.textWidth, contentWidth);\n  contentBlock.outerHeight = contentBlock.height = retrieve2(style.textHeight, contentHeight);\n\n  if (stlPadding) {\n    contentBlock.outerWidth += stlPadding[1] + stlPadding[3];\n    contentBlock.outerHeight += stlPadding[0] + stlPadding[2];\n  }\n\n  for (var i = 0; i < pendingList.length; i++) {\n    var token = pendingList[i];\n    var percentWidth = token.percentWidth; // Should not base on outerWidth, because token can not be placed out of padding.\n\n    token.width = parseInt(percentWidth, 10) / 100 * contentWidth;\n  }\n\n  return contentBlock;\n}\n\nfunction pushTokens(block, str, styleName) {\n  var isEmptyStr = str === '';\n  var strs = str.split('\\n');\n  var lines = block.lines;\n\n  for (var i = 0; i < strs.length; i++) {\n    var text = strs[i];\n    var token = {\n      styleName: styleName,\n      text: text,\n      isLineHolder: !text && !isEmptyStr\n    }; // The first token should be appended to the last line.\n\n    if (!i) {\n      var tokens = (lines[lines.length - 1] || (lines[0] = {\n        tokens: []\n      })).tokens; // Consider cases:\n      // (1) ''.split('\\n') => ['', '\\n', ''], the '' at the first item\n      // (which is a placeholder) should be replaced by new token.\n      // (2) A image backage, where token likes {a|}.\n      // (3) A redundant '' will affect textAlign in line.\n      // (4) tokens with the same tplName should not be merged, because\n      // they should be displayed in different box (with border and padding).\n\n      var tokensLen = tokens.length;\n      tokensLen === 1 && tokens[0].isLineHolder ? tokens[0] = token : // Consider text is '', only insert when it is the \"lineHolder\" or\n      // \"emptyStr\". Otherwise a redundant '' will affect textAlign in line.\n      (text || !tokensLen || isEmptyStr) && tokens.push(token);\n    } // Other tokens always start a new line.\n    else {\n        // If there is '', insert it as a placeholder.\n        lines.push({\n          tokens: [token]\n        });\n      }\n  }\n}\n\nfunction makeFont(style) {\n  // FIXME in node-canvas fontWeight is before fontStyle\n  // Use `fontSize` `fontFamily` to check whether font properties are defined.\n  var font = (style.fontSize || style.fontFamily) && [style.fontStyle, style.fontWeight, (style.fontSize || 12) + 'px', // If font properties are defined, `fontFamily` should not be ignored.\n  style.fontFamily || 'sans-serif'].join(' ');\n  return font && trim(font) || style.textFont || style.font;\n}\n\nexports.DEFAULT_FONT = DEFAULT_FONT;\nexports.$override = $override;\nexports.getWidth = getWidth;\nexports.getBoundingRect = getBoundingRect;\nexports.adjustTextX = adjustTextX;\nexports.adjustTextY = adjustTextY;\nexports.adjustTextPositionOnRect = adjustTextPositionOnRect;\nexports.truncateText = truncateText;\nexports.getLineHeight = getLineHeight;\nexports.measureText = measureText;\nexports.parsePlainText = parsePlainText;\nexports.parseRichText = parseRichText;\nexports.makeFont = makeFont;","/**\n * @param {Object} ctx\n * @param {Object} shape\n * @param {number} shape.x\n * @param {number} shape.y\n * @param {number} shape.width\n * @param {number} shape.height\n * @param {number} shape.r\n */\nfunction buildPath(ctx, shape) {\n  var x = shape.x;\n  var y = shape.y;\n  var width = shape.width;\n  var height = shape.height;\n  var r = shape.r;\n  var r1;\n  var r2;\n  var r3;\n  var r4; // Convert width and height to positive for better borderRadius\n\n  if (width < 0) {\n    x = x + width;\n    width = -width;\n  }\n\n  if (height < 0) {\n    y = y + height;\n    height = -height;\n  }\n\n  if (typeof r === 'number') {\n    r1 = r2 = r3 = r4 = r;\n  } else if (r instanceof Array) {\n    if (r.length === 1) {\n      r1 = r2 = r3 = r4 = r[0];\n    } else if (r.length === 2) {\n      r1 = r3 = r[0];\n      r2 = r4 = r[1];\n    } else if (r.length === 3) {\n      r1 = r[0];\n      r2 = r4 = r[1];\n      r3 = r[2];\n    } else {\n      r1 = r[0];\n      r2 = r[1];\n      r3 = r[2];\n      r4 = r[3];\n    }\n  } else {\n    r1 = r2 = r3 = r4 = 0;\n  }\n\n  var total;\n\n  if (r1 + r2 > width) {\n    total = r1 + r2;\n    r1 *= width / total;\n    r2 *= width / total;\n  }\n\n  if (r3 + r4 > width) {\n    total = r3 + r4;\n    r3 *= width / total;\n    r4 *= width / total;\n  }\n\n  if (r2 + r3 > height) {\n    total = r2 + r3;\n    r2 *= height / total;\n    r3 *= height / total;\n  }\n\n  if (r1 + r4 > height) {\n    total = r1 + r4;\n    r1 *= height / total;\n    r4 *= height / total;\n  }\n\n  ctx.moveTo(x + r1, y);\n  ctx.lineTo(x + width - r2, y);\n  r2 !== 0 && ctx.arc(x + width - r2, y + r2, r2, -Math.PI / 2, 0);\n  ctx.lineTo(x + width, y + height - r3);\n  r3 !== 0 && ctx.arc(x + width - r3, y + height - r3, r3, 0, Math.PI / 2);\n  ctx.lineTo(x + r4, y + height);\n  r4 !== 0 && ctx.arc(x + r4, y + height - r4, r4, Math.PI / 2, Math.PI);\n  ctx.lineTo(x, y + r1);\n  r1 !== 0 && ctx.arc(x + r1, y + r1, r1, Math.PI, Math.PI * 1.5);\n}\n\nexports.buildPath = buildPath;","var PI2 = Math.PI * 2;\n\nfunction normalizeRadian(angle) {\n  angle %= PI2;\n\n  if (angle < 0) {\n    angle += PI2;\n  }\n\n  return angle;\n}\n\nexports.normalizeRadian = normalizeRadian;","var smoothSpline = require(\"./smoothSpline\");\n\nvar smoothBezier = require(\"./smoothBezier\");\n\nfunction buildPath(ctx, shape, closePath) {\n  var points = shape.points;\n  var smooth = shape.smooth;\n\n  if (points && points.length >= 2) {\n    if (smooth && smooth !== 'spline') {\n      var controlPoints = smoothBezier(points, smooth, closePath, shape.smoothConstraint);\n      ctx.moveTo(points[0][0], points[0][1]);\n      var len = points.length;\n\n      for (var i = 0; i < (closePath ? len : len - 1); i++) {\n        var cp1 = controlPoints[i * 2];\n        var cp2 = controlPoints[i * 2 + 1];\n        var p = points[(i + 1) % len];\n        ctx.bezierCurveTo(cp1[0], cp1[1], cp2[0], cp2[1], p[0], p[1]);\n      }\n    } else {\n      if (smooth === 'spline') {\n        points = smoothSpline(points, closePath);\n      }\n\n      ctx.moveTo(points[0][0], points[0][1]);\n\n      for (var i = 1, l = points.length; i < l; i++) {\n        ctx.lineTo(points[i][0], points[i][1]);\n      }\n    }\n\n    closePath && ctx.closePath();\n  }\n}\n\nexports.buildPath = buildPath;","/**\n * Sub-pixel optimize for canvas rendering, prevent from blur\n * when rendering a thin vertical/horizontal line.\n */\nvar round = Math.round;\n/**\n * Sub pixel optimize line for canvas\n *\n * @param {Object} outputShape The modification will be performed on `outputShape`.\n *                 `outputShape` and `inputShape` can be the same object.\n *                 `outputShape` object can be used repeatly, because all of\n *                 the `x1`, `x2`, `y1`, `y2` will be assigned in this method.\n * @param {Object} [inputShape]\n * @param {number} [inputShape.x1]\n * @param {number} [inputShape.y1]\n * @param {number} [inputShape.x2]\n * @param {number} [inputShape.y2]\n * @param {Object} [style]\n * @param {number} [style.lineWidth]\n */\n\nfunction subPixelOptimizeLine(outputShape, inputShape, style) {\n  var lineWidth = style && style.lineWidth;\n\n  if (!inputShape || !lineWidth) {\n    return;\n  }\n\n  var x1 = inputShape.x1;\n  var x2 = inputShape.x2;\n  var y1 = inputShape.y1;\n  var y2 = inputShape.y2;\n\n  if (round(x1 * 2) === round(x2 * 2)) {\n    outputShape.x1 = outputShape.x2 = subPixelOptimize(x1, lineWidth, true);\n  } else {\n    outputShape.x1 = x1;\n    outputShape.x2 = x2;\n  }\n\n  if (round(y1 * 2) === round(y2 * 2)) {\n    outputShape.y1 = outputShape.y2 = subPixelOptimize(y1, lineWidth, true);\n  } else {\n    outputShape.y1 = y1;\n    outputShape.y2 = y2;\n  }\n}\n/**\n * Sub pixel optimize rect for canvas\n *\n * @param {Object} outputShape The modification will be performed on `outputShape`.\n *                 `outputShape` and `inputShape` can be the same object.\n *                 `outputShape` object can be used repeatly, because all of\n *                 the `x`, `y`, `width`, `height` will be assigned in this method.\n * @param {Object} [inputShape]\n * @param {number} [inputShape.x]\n * @param {number} [inputShape.y]\n * @param {number} [inputShape.width]\n * @param {number} [inputShape.height]\n * @param {Object} [style]\n * @param {number} [style.lineWidth]\n */\n\n\nfunction subPixelOptimizeRect(outputShape, inputShape, style) {\n  var lineWidth = style && style.lineWidth;\n\n  if (!inputShape || !lineWidth) {\n    return;\n  }\n\n  var originX = inputShape.x;\n  var originY = inputShape.y;\n  var originWidth = inputShape.width;\n  var originHeight = inputShape.height;\n  outputShape.x = subPixelOptimize(originX, lineWidth, true);\n  outputShape.y = subPixelOptimize(originY, lineWidth, true);\n  outputShape.width = Math.max(subPixelOptimize(originX + originWidth, lineWidth, false) - outputShape.x, originWidth === 0 ? 0 : 1);\n  outputShape.height = Math.max(subPixelOptimize(originY + originHeight, lineWidth, false) - outputShape.y, originHeight === 0 ? 0 : 1);\n}\n/**\n * Sub pixel optimize for canvas\n *\n * @param {number} position Coordinate, such as x, y\n * @param {number} lineWidth Should be nonnegative integer.\n * @param {boolean=} positiveOrNegative Default false (negative).\n * @return {number} Optimized position.\n */\n\n\nfunction subPixelOptimize(position, lineWidth, positiveOrNegative) {\n  // Assure that (position + lineWidth / 2) is near integer edge,\n  // otherwise line will be fuzzy in canvas.\n  var doubledPosition = round(position * 2);\n  return (doubledPosition + round(lineWidth)) % 2 === 0 ? doubledPosition / 2 : (doubledPosition + (positiveOrNegative ? 1 : -1)) / 2;\n}\n\nexports.subPixelOptimizeLine = subPixelOptimizeLine;\nexports.subPixelOptimizeRect = subPixelOptimizeRect;\nexports.subPixelOptimize = subPixelOptimize;","/**\n * @param {Array.<Object>} colorStops\n */\nvar Gradient = function (colorStops) {\n  this.colorStops = colorStops || [];\n};\n\nGradient.prototype = {\n  constructor: Gradient,\n  addColorStop: function (offset, color) {\n    this.colorStops.push({\n      offset: offset,\n      color: color\n    });\n  }\n};\nvar _default = Gradient;\nmodule.exports = _default;","module.exports = require('./src/liquidFill');\n","var echarts = require('echarts/lib/echarts');\n\nrequire('./liquidFillSeries');\nrequire('./liquidFillView');\n\n\necharts.registerVisual(\n    echarts.util.curry(\n        require('echarts/lib/visual/dataColor'), 'liquidFill'\n    )\n);\n","var completeDimensions = require('echarts/lib/data/helper/completeDimensions');\nvar echarts = require('echarts/lib/echarts');\n\necharts.extendSeriesModel({\n\n    type: 'series.liquidFill',\n\n    visualColorAccessPath: 'textStyle.normal.color',\n\n    optionUpdated: function () {\n        var option = this.option;\n        option.gridSize = Math.max(Math.floor(option.gridSize), 4);\n    },\n\n    getInitialData: function (option, ecModel) {\n        var dimensions = completeDimensions(['value'], option.data);\n        var list = new echarts.List(dimensions, this);\n        list.initData(option.data);\n        return list;\n    },\n\n    defaultOption: {\n        color: ['#294D99', '#156ACF', '#1598ED', '#45BDFF'],\n        center: ['50%', '50%'],\n        radius: '50%',\n        amplitude: '8%',\n        waveLength: '80%',\n        phase: 'auto',\n        period: 'auto',\n        direction: 'right',\n        shape: 'circle',\n\n        waveAnimation: true,\n        animationEasing: 'linear',\n        animationEasingUpdate: 'linear',\n        animationDuration: 2000,\n        animationDurationUpdate: 1000,\n\n        outline: {\n            show: true,\n            borderDistance: 8,\n            itemStyle: {\n                color: 'none',\n                borderColor: '#294D99',\n                borderWidth: 8,\n                shadowBlur: 20,\n                shadowColor: 'rgba(0, 0, 0, 0.25)'\n            }\n        },\n\n        backgroundStyle: {\n            color: '#E3F7FF'\n        },\n\n        itemStyle: {\n            opacity: 0.95,\n            shadowBlur: 50,\n            shadowColor: 'rgba(0, 0, 0, 0.4)'\n        },\n\n        label: {\n            show: true,\n            color: '#294D99',\n            insideColor: '#fff',\n            fontSize: 50,\n            fontWeight: 'bold',\n\n            align: 'center',\n            baseline: 'middle',\n            position: 'inside'\n        },\n\n        emphasis: {\n            itemStyle: {\n                opacity: 0.8\n            }\n        }\n    }\n});\n","\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar _util = require(\"zrender/lib/core/util\");\n\nvar createHashMap = _util.createHashMap;\nvar each = _util.each;\nvar isString = _util.isString;\nvar defaults = _util.defaults;\nvar extend = _util.extend;\nvar isObject = _util.isObject;\nvar clone = _util.clone;\n\nvar _model = require(\"../../util/model\");\n\nvar normalizeToArray = _model.normalizeToArray;\n\nvar _sourceHelper = require(\"./sourceHelper\");\n\nvar guessOrdinal = _sourceHelper.guessOrdinal;\n\nvar Source = require(\"../Source\");\n\nvar _dimensionHelper = require(\"./dimensionHelper\");\n\nvar OTHER_DIMENSIONS = _dimensionHelper.OTHER_DIMENSIONS;\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n/**\n * @deprecated\n * Use `echarts/data/helper/createDimensions` instead.\n */\n\n/**\n * @see {module:echarts/test/ut/spec/data/completeDimensions}\n *\n * Complete the dimensions array, by user defined `dimension` and `encode`,\n * and guessing from the data structure.\n * If no 'value' dimension specified, the first no-named dimension will be\n * named as 'value'.\n *\n * @param {Array.<string>} sysDims Necessary dimensions, like ['x', 'y'], which\n *      provides not only dim template, but also default order.\n *      properties: 'name', 'type', 'displayName'.\n *      `name` of each item provides default coord name.\n *      [{dimsDef: [string|Object, ...]}, ...] dimsDef of sysDim item provides default dim name, and\n *                                    provide dims count that the sysDim required.\n *      [{ordinalMeta}] can be specified.\n * @param {module:echarts/data/Source|Array|Object} source or data (for compatibal with pervious)\n * @param {Object} [opt]\n * @param {Array.<Object|string>} [opt.dimsDef] option.series.dimensions User defined dimensions\n *      For example: ['asdf', {name, type}, ...].\n * @param {Object|HashMap} [opt.encodeDef] option.series.encode {x: 2, y: [3, 1], tooltip: [1, 2], label: 3}\n * @param {string} [opt.generateCoord] Generate coord dim with the given name.\n *                 If not specified, extra dim names will be:\n *                 'value', 'value0', 'value1', ...\n * @param {number} [opt.generateCoordCount] By default, the generated dim name is `generateCoord`.\n *                 If `generateCoordCount` specified, the generated dim names will be:\n *                 `generateCoord` + 0, `generateCoord` + 1, ...\n *                 can be Infinity, indicate that use all of the remain columns.\n * @param {number} [opt.dimCount] If not specified, guess by the first data item.\n * @param {number} [opt.encodeDefaulter] If not specified, auto find the next available data dim.\n * @return {Array.<Object>} [{\n *      name: string mandatory,\n *      displayName: string, the origin name in dimsDef, see source helper.\n *                 If displayName given, the tooltip will displayed vertically.\n *      coordDim: string mandatory,\n *      coordDimIndex: number mandatory,\n *      type: string optional,\n *      otherDims: { never null/undefined\n *          tooltip: number optional,\n *          label: number optional,\n *          itemName: number optional,\n *          seriesName: number optional,\n *      },\n *      isExtraCoord: boolean true if coord is generated\n *          (not specified in encode and not series specified)\n *      other props ...\n * }]\n */\nfunction completeDimensions(sysDims, source, opt) {\n  if (!Source.isInstance(source)) {\n    source = Source.seriesDataToSource(source);\n  }\n\n  opt = opt || {};\n  sysDims = (sysDims || []).slice();\n  var dimsDef = (opt.dimsDef || []).slice();\n  var encodeDef = createHashMap(opt.encodeDef);\n  var dataDimNameMap = createHashMap();\n  var coordDimNameMap = createHashMap(); // var valueCandidate;\n\n  var result = [];\n  var dimCount = getDimCount(source, sysDims, dimsDef, opt.dimCount); // Apply user defined dims (`name` and `type`) and init result.\n\n  for (var i = 0; i < dimCount; i++) {\n    var dimDefItem = dimsDef[i] = extend({}, isObject(dimsDef[i]) ? dimsDef[i] : {\n      name: dimsDef[i]\n    });\n    var userDimName = dimDefItem.name;\n    var resultItem = result[i] = {\n      otherDims: {}\n    }; // Name will be applied later for avoiding duplication.\n\n    if (userDimName != null && dataDimNameMap.get(userDimName) == null) {\n      // Only if `series.dimensions` is defined in option\n      // displayName, will be set, and dimension will be diplayed vertically in\n      // tooltip by default.\n      resultItem.name = resultItem.displayName = userDimName;\n      dataDimNameMap.set(userDimName, i);\n    }\n\n    dimDefItem.type != null && (resultItem.type = dimDefItem.type);\n    dimDefItem.displayName != null && (resultItem.displayName = dimDefItem.displayName);\n  } // Set `coordDim` and `coordDimIndex` by `encodeDef` and normalize `encodeDef`.\n\n\n  encodeDef.each(function (dataDims, coordDim) {\n    dataDims = normalizeToArray(dataDims).slice(); // Note: It is allowed that `dataDims.length` is `0`, e.g., options is\n    // `{encode: {x: -1, y: 1}}`. Should not filter anything in\n    // this case.\n\n    if (dataDims.length === 1 && dataDims[0] < 0) {\n      encodeDef.set(coordDim, false);\n      return;\n    }\n\n    var validDataDims = encodeDef.set(coordDim, []);\n    each(dataDims, function (resultDimIdx, idx) {\n      // The input resultDimIdx can be dim name or index.\n      isString(resultDimIdx) && (resultDimIdx = dataDimNameMap.get(resultDimIdx));\n\n      if (resultDimIdx != null && resultDimIdx < dimCount) {\n        validDataDims[idx] = resultDimIdx;\n        applyDim(result[resultDimIdx], coordDim, idx);\n      }\n    });\n  }); // Apply templetes and default order from `sysDims`.\n\n  var availDimIdx = 0;\n  each(sysDims, function (sysDimItem, sysDimIndex) {\n    var coordDim;\n    var sysDimItem;\n    var sysDimItemDimsDef;\n    var sysDimItemOtherDims;\n\n    if (isString(sysDimItem)) {\n      coordDim = sysDimItem;\n      sysDimItem = {};\n    } else {\n      coordDim = sysDimItem.name;\n      var ordinalMeta = sysDimItem.ordinalMeta;\n      sysDimItem.ordinalMeta = null;\n      sysDimItem = clone(sysDimItem);\n      sysDimItem.ordinalMeta = ordinalMeta; // `coordDimIndex` should not be set directly.\n\n      sysDimItemDimsDef = sysDimItem.dimsDef;\n      sysDimItemOtherDims = sysDimItem.otherDims;\n      sysDimItem.name = sysDimItem.coordDim = sysDimItem.coordDimIndex = sysDimItem.dimsDef = sysDimItem.otherDims = null;\n    }\n\n    var dataDims = encodeDef.get(coordDim); // negative resultDimIdx means no need to mapping.\n\n    if (dataDims === false) {\n      return;\n    }\n\n    var dataDims = normalizeToArray(dataDims); // dimensions provides default dim sequences.\n\n    if (!dataDims.length) {\n      for (var i = 0; i < (sysDimItemDimsDef && sysDimItemDimsDef.length || 1); i++) {\n        while (availDimIdx < result.length && result[availDimIdx].coordDim != null) {\n          availDimIdx++;\n        }\n\n        availDimIdx < result.length && dataDims.push(availDimIdx++);\n      }\n    } // Apply templates.\n\n\n    each(dataDims, function (resultDimIdx, coordDimIndex) {\n      var resultItem = result[resultDimIdx];\n      applyDim(defaults(resultItem, sysDimItem), coordDim, coordDimIndex);\n\n      if (resultItem.name == null && sysDimItemDimsDef) {\n        var sysDimItemDimsDefItem = sysDimItemDimsDef[coordDimIndex];\n        !isObject(sysDimItemDimsDefItem) && (sysDimItemDimsDefItem = {\n          name: sysDimItemDimsDefItem\n        });\n        resultItem.name = resultItem.displayName = sysDimItemDimsDefItem.name;\n        resultItem.defaultTooltip = sysDimItemDimsDefItem.defaultTooltip;\n      } // FIXME refactor, currently only used in case: {otherDims: {tooltip: false}}\n\n\n      sysDimItemOtherDims && defaults(resultItem.otherDims, sysDimItemOtherDims);\n    });\n  });\n\n  function applyDim(resultItem, coordDim, coordDimIndex) {\n    if (OTHER_DIMENSIONS.get(coordDim) != null) {\n      resultItem.otherDims[coordDim] = coordDimIndex;\n    } else {\n      resultItem.coordDim = coordDim;\n      resultItem.coordDimIndex = coordDimIndex;\n      coordDimNameMap.set(coordDim, true);\n    }\n  } // Make sure the first extra dim is 'value'.\n\n\n  var generateCoord = opt.generateCoord;\n  var generateCoordCount = opt.generateCoordCount;\n  var fromZero = generateCoordCount != null;\n  generateCoordCount = generateCoord ? generateCoordCount || 1 : 0;\n  var extra = generateCoord || 'value'; // Set dim `name` and other `coordDim` and other props.\n\n  for (var resultDimIdx = 0; resultDimIdx < dimCount; resultDimIdx++) {\n    var resultItem = result[resultDimIdx] = result[resultDimIdx] || {};\n    var coordDim = resultItem.coordDim;\n\n    if (coordDim == null) {\n      resultItem.coordDim = genName(extra, coordDimNameMap, fromZero);\n      resultItem.coordDimIndex = 0;\n\n      if (!generateCoord || generateCoordCount <= 0) {\n        resultItem.isExtraCoord = true;\n      }\n\n      generateCoordCount--;\n    }\n\n    resultItem.name == null && (resultItem.name = genName(resultItem.coordDim, dataDimNameMap));\n\n    if (resultItem.type == null && guessOrdinal(source, resultDimIdx, resultItem.name)) {\n      resultItem.type = 'ordinal';\n    }\n  }\n\n  return result;\n} // ??? TODO\n// Originally detect dimCount by data[0]. Should we\n// optimize it to only by sysDims and dimensions and encode.\n// So only necessary dims will be initialized.\n// But\n// (1) custom series should be considered. where other dims\n// may be visited.\n// (2) sometimes user need to calcualte bubble size or use visualMap\n// on other dimensions besides coordSys needed.\n// So, dims that is not used by system, should be shared in storage?\n\n\nfunction getDimCount(source, sysDims, dimsDef, optDimCount) {\n  // Note that the result dimCount should not small than columns count\n  // of data, otherwise `dataDimNameMap` checking will be incorrect.\n  var dimCount = Math.max(source.dimensionsDetectCount || 1, sysDims.length, dimsDef.length, optDimCount || 0);\n  each(sysDims, function (sysDimItem) {\n    var sysDimItemDimsDef = sysDimItem.dimsDef;\n    sysDimItemDimsDef && (dimCount = Math.max(dimCount, sysDimItemDimsDef.length));\n  });\n  return dimCount;\n}\n\nfunction genName(name, map, fromZero) {\n  if (fromZero || map.get(name) != null) {\n    var i = 0;\n\n    while (map.get(name + i) != null) {\n      i++;\n    }\n\n    name += i;\n  }\n\n  map.set(name, true);\n  return name;\n}\n\nvar _default = completeDimensions;\nmodule.exports = _default;","\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar _config = require(\"../../config\");\n\nvar __DEV__ = _config.__DEV__;\n\nvar _model = require(\"../../util/model\");\n\nvar makeInner = _model.makeInner;\nvar getDataItemValue = _model.getDataItemValue;\n\nvar _referHelper = require(\"../../model/referHelper\");\n\nvar getCoordSysDefineBySeries = _referHelper.getCoordSysDefineBySeries;\n\nvar _util = require(\"zrender/lib/core/util\");\n\nvar createHashMap = _util.createHashMap;\nvar each = _util.each;\nvar map = _util.map;\nvar isArray = _util.isArray;\nvar isString = _util.isString;\nvar isObject = _util.isObject;\nvar isTypedArray = _util.isTypedArray;\nvar isArrayLike = _util.isArrayLike;\nvar extend = _util.extend;\nvar assert = _util.assert;\n\nvar Source = require(\"../Source\");\n\nvar _sourceType = require(\"./sourceType\");\n\nvar SOURCE_FORMAT_ORIGINAL = _sourceType.SOURCE_FORMAT_ORIGINAL;\nvar SOURCE_FORMAT_ARRAY_ROWS = _sourceType.SOURCE_FORMAT_ARRAY_ROWS;\nvar SOURCE_FORMAT_OBJECT_ROWS = _sourceType.SOURCE_FORMAT_OBJECT_ROWS;\nvar SOURCE_FORMAT_KEYED_COLUMNS = _sourceType.SOURCE_FORMAT_KEYED_COLUMNS;\nvar SOURCE_FORMAT_UNKNOWN = _sourceType.SOURCE_FORMAT_UNKNOWN;\nvar SOURCE_FORMAT_TYPED_ARRAY = _sourceType.SOURCE_FORMAT_TYPED_ARRAY;\nvar SERIES_LAYOUT_BY_ROW = _sourceType.SERIES_LAYOUT_BY_ROW;\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\nvar inner = makeInner();\n/**\n * @see {module:echarts/data/Source}\n * @param {module:echarts/component/dataset/DatasetModel} datasetModel\n * @return {string} sourceFormat\n */\n\nfunction detectSourceFormat(datasetModel) {\n  var data = datasetModel.option.source;\n  var sourceFormat = SOURCE_FORMAT_UNKNOWN;\n\n  if (isTypedArray(data)) {\n    sourceFormat = SOURCE_FORMAT_TYPED_ARRAY;\n  } else if (isArray(data)) {\n    // FIXME Whether tolerate null in top level array?\n    if (data.length === 0) {\n      sourceFormat = SOURCE_FORMAT_ARRAY_ROWS;\n    }\n\n    for (var i = 0, len = data.length; i < len; i++) {\n      var item = data[i];\n\n      if (item == null) {\n        continue;\n      } else if (isArray(item)) {\n        sourceFormat = SOURCE_FORMAT_ARRAY_ROWS;\n        break;\n      } else if (isObject(item)) {\n        sourceFormat = SOURCE_FORMAT_OBJECT_ROWS;\n        break;\n      }\n    }\n  } else if (isObject(data)) {\n    for (var key in data) {\n      if (data.hasOwnProperty(key) && isArrayLike(data[key])) {\n        sourceFormat = SOURCE_FORMAT_KEYED_COLUMNS;\n        break;\n      }\n    }\n  } else if (data != null) {\n    throw new Error('Invalid data');\n  }\n\n  inner(datasetModel).sourceFormat = sourceFormat;\n}\n/**\n * [Scenarios]:\n * (1) Provide source data directly:\n *     series: {\n *         encode: {...},\n *         dimensions: [...]\n *         seriesLayoutBy: 'row',\n *         data: [[...]]\n *     }\n * (2) Refer to datasetModel.\n *     series: [{\n *         encode: {...}\n *         // Ignore datasetIndex means `datasetIndex: 0`\n *         // and the dimensions defination in dataset is used\n *     }, {\n *         encode: {...},\n *         seriesLayoutBy: 'column',\n *         datasetIndex: 1\n *     }]\n *\n * Get data from series itself or datset.\n * @return {module:echarts/data/Source} source\n */\n\n\nfunction getSource(seriesModel) {\n  return inner(seriesModel).source;\n}\n/**\n * MUST be called before mergeOption of all series.\n * @param {module:echarts/model/Global} ecModel\n */\n\n\nfunction resetSourceDefaulter(ecModel) {\n  // `datasetMap` is used to make default encode.\n  inner(ecModel).datasetMap = createHashMap();\n}\n/**\n * [Caution]:\n * MUST be called after series option merged and\n * before \"series.getInitailData()\" called.\n *\n * [The rule of making default encode]:\n * Category axis (if exists) alway map to the first dimension.\n * Each other axis occupies a subsequent dimension.\n *\n * [Why make default encode]:\n * Simplify the typing of encode in option, avoiding the case like that:\n * series: [{encode: {x: 0, y: 1}}, {encode: {x: 0, y: 2}}, {encode: {x: 0, y: 3}}],\n * where the \"y\" have to be manually typed as \"1, 2, 3, ...\".\n *\n * @param {module:echarts/model/Series} seriesModel\n */\n\n\nfunction prepareSource(seriesModel) {\n  var seriesOption = seriesModel.option;\n  var data = seriesOption.data;\n  var sourceFormat = isTypedArray(data) ? SOURCE_FORMAT_TYPED_ARRAY : SOURCE_FORMAT_ORIGINAL;\n  var fromDataset = false;\n  var seriesLayoutBy = seriesOption.seriesLayoutBy;\n  var sourceHeader = seriesOption.sourceHeader;\n  var dimensionsDefine = seriesOption.dimensions;\n  var datasetModel = getDatasetModel(seriesModel);\n\n  if (datasetModel) {\n    var datasetOption = datasetModel.option;\n    data = datasetOption.source;\n    sourceFormat = inner(datasetModel).sourceFormat;\n    fromDataset = true; // These settings from series has higher priority.\n\n    seriesLayoutBy = seriesLayoutBy || datasetOption.seriesLayoutBy;\n    sourceHeader == null && (sourceHeader = datasetOption.sourceHeader);\n    dimensionsDefine = dimensionsDefine || datasetOption.dimensions;\n  }\n\n  var completeResult = completeBySourceData(data, sourceFormat, seriesLayoutBy, sourceHeader, dimensionsDefine); // Note: dataset option does not have `encode`.\n\n  var encodeDefine = seriesOption.encode;\n\n  if (!encodeDefine && datasetModel) {\n    encodeDefine = makeDefaultEncode(seriesModel, datasetModel, data, sourceFormat, seriesLayoutBy, completeResult);\n  }\n\n  inner(seriesModel).source = new Source({\n    data: data,\n    fromDataset: fromDataset,\n    seriesLayoutBy: seriesLayoutBy,\n    sourceFormat: sourceFormat,\n    dimensionsDefine: completeResult.dimensionsDefine,\n    startIndex: completeResult.startIndex,\n    dimensionsDetectCount: completeResult.dimensionsDetectCount,\n    encodeDefine: encodeDefine\n  });\n} // return {startIndex, dimensionsDefine, dimensionsCount}\n\n\nfunction completeBySourceData(data, sourceFormat, seriesLayoutBy, sourceHeader, dimensionsDefine) {\n  if (!data) {\n    return {\n      dimensionsDefine: normalizeDimensionsDefine(dimensionsDefine)\n    };\n  }\n\n  var dimensionsDetectCount;\n  var startIndex;\n  var findPotentialName;\n\n  if (sourceFormat === SOURCE_FORMAT_ARRAY_ROWS) {\n    // Rule: Most of the first line are string: it is header.\n    // Caution: consider a line with 5 string and 1 number,\n    // it still can not be sure it is a head, because the\n    // 5 string may be 5 values of category columns.\n    if (sourceHeader === 'auto' || sourceHeader == null) {\n      arrayRowsTravelFirst(function (val) {\n        // '-' is regarded as null/undefined.\n        if (val != null && val !== '-') {\n          if (isString(val)) {\n            startIndex == null && (startIndex = 1);\n          } else {\n            startIndex = 0;\n          }\n        } // 10 is an experience number, avoid long loop.\n\n      }, seriesLayoutBy, data, 10);\n    } else {\n      startIndex = sourceHeader ? 1 : 0;\n    }\n\n    if (!dimensionsDefine && startIndex === 1) {\n      dimensionsDefine = [];\n      arrayRowsTravelFirst(function (val, index) {\n        dimensionsDefine[index] = val != null ? val : '';\n      }, seriesLayoutBy, data);\n    }\n\n    dimensionsDetectCount = dimensionsDefine ? dimensionsDefine.length : seriesLayoutBy === SERIES_LAYOUT_BY_ROW ? data.length : data[0] ? data[0].length : null;\n  } else if (sourceFormat === SOURCE_FORMAT_OBJECT_ROWS) {\n    if (!dimensionsDefine) {\n      dimensionsDefine = objectRowsCollectDimensions(data);\n      findPotentialName = true;\n    }\n  } else if (sourceFormat === SOURCE_FORMAT_KEYED_COLUMNS) {\n    if (!dimensionsDefine) {\n      dimensionsDefine = [];\n      findPotentialName = true;\n      each(data, function (colArr, key) {\n        dimensionsDefine.push(key);\n      });\n    }\n  } else if (sourceFormat === SOURCE_FORMAT_ORIGINAL) {\n    var value0 = getDataItemValue(data[0]);\n    dimensionsDetectCount = isArray(value0) && value0.length || 1;\n  } else if (sourceFormat === SOURCE_FORMAT_TYPED_ARRAY) {}\n\n  var potentialNameDimIndex;\n\n  if (findPotentialName) {\n    each(dimensionsDefine, function (dim, idx) {\n      if ((isObject(dim) ? dim.name : dim) === 'name') {\n        potentialNameDimIndex = idx;\n      }\n    });\n  }\n\n  return {\n    startIndex: startIndex,\n    dimensionsDefine: normalizeDimensionsDefine(dimensionsDefine),\n    dimensionsDetectCount: dimensionsDetectCount,\n    potentialNameDimIndex: potentialNameDimIndex // TODO: potentialIdDimIdx\n\n  };\n} // Consider dimensions defined like ['A', 'price', 'B', 'price', 'C', 'price'],\n// which is reasonable. But dimension name is duplicated.\n// Returns undefined or an array contains only object without null/undefiend or string.\n\n\nfunction normalizeDimensionsDefine(dimensionsDefine) {\n  if (!dimensionsDefine) {\n    // The meaning of null/undefined is different from empty array.\n    return;\n  }\n\n  var nameMap = createHashMap();\n  return map(dimensionsDefine, function (item, index) {\n    item = extend({}, isObject(item) ? item : {\n      name: item\n    }); // User can set null in dimensions.\n    // We dont auto specify name, othewise a given name may\n    // cause it be refered unexpectedly.\n\n    if (item.name == null) {\n      return item;\n    } // Also consider number form like 2012.\n\n\n    item.name += ''; // User may also specify displayName.\n    // displayName will always exists except user not\n    // specified or dim name is not specified or detected.\n    // (A auto generated dim name will not be used as\n    // displayName).\n\n    if (item.displayName == null) {\n      item.displayName = item.name;\n    }\n\n    var exist = nameMap.get(item.name);\n\n    if (!exist) {\n      nameMap.set(item.name, {\n        count: 1\n      });\n    } else {\n      item.name += '-' + exist.count++;\n    }\n\n    return item;\n  });\n}\n\nfunction arrayRowsTravelFirst(cb, seriesLayoutBy, data, maxLoop) {\n  maxLoop == null && (maxLoop = Infinity);\n\n  if (seriesLayoutBy === SERIES_LAYOUT_BY_ROW) {\n    for (var i = 0; i < data.length && i < maxLoop; i++) {\n      cb(data[i] ? data[i][0] : null, i);\n    }\n  } else {\n    var value0 = data[0] || [];\n\n    for (var i = 0; i < value0.length && i < maxLoop; i++) {\n      cb(value0[i], i);\n    }\n  }\n}\n\nfunction objectRowsCollectDimensions(data) {\n  var firstIndex = 0;\n  var obj;\n\n  while (firstIndex < data.length && !(obj = data[firstIndex++])) {} // jshint ignore: line\n\n\n  if (obj) {\n    var dimensions = [];\n    each(obj, function (value, key) {\n      dimensions.push(key);\n    });\n    return dimensions;\n  }\n} // ??? TODO merge to completedimensions, where also has\n// default encode making logic. And the default rule\n// should depends on series? consider 'map'.\n\n\nfunction makeDefaultEncode(seriesModel, datasetModel, data, sourceFormat, seriesLayoutBy, completeResult) {\n  var coordSysDefine = getCoordSysDefineBySeries(seriesModel);\n  var encode = {}; // var encodeTooltip = [];\n  // var encodeLabel = [];\n\n  var encodeItemName = [];\n  var encodeSeriesName = [];\n  var seriesType = seriesModel.subType; // ??? TODO refactor: provide by series itself.\n  // Consider the case: 'map' series is based on geo coordSys,\n  // 'graph', 'heatmap' can be based on cartesian. But can not\n  // give default rule simply here.\n\n  var nSeriesMap = createHashMap(['pie', 'map', 'funnel']);\n  var cSeriesMap = createHashMap(['line', 'bar', 'pictorialBar', 'scatter', 'effectScatter', 'candlestick', 'boxplot']); // Usually in this case series will use the first data\n  // dimension as the \"value\" dimension, or other default\n  // processes respectively.\n\n  if (coordSysDefine && cSeriesMap.get(seriesType) != null) {\n    var ecModel = seriesModel.ecModel;\n    var datasetMap = inner(ecModel).datasetMap;\n    var key = datasetModel.uid + '_' + seriesLayoutBy;\n    var datasetRecord = datasetMap.get(key) || datasetMap.set(key, {\n      categoryWayDim: 1,\n      valueWayDim: 0\n    }); // TODO\n    // Auto detect first time axis and do arrangement.\n\n    each(coordSysDefine.coordSysDims, function (coordDim) {\n      // In value way.\n      if (coordSysDefine.firstCategoryDimIndex == null) {\n        var dataDim = datasetRecord.valueWayDim++;\n        encode[coordDim] = dataDim; // ??? TODO give a better default series name rule?\n        // especially when encode x y specified.\n        // consider: when mutiple series share one dimension\n        // category axis, series name should better use\n        // the other dimsion name. On the other hand, use\n        // both dimensions name.\n\n        encodeSeriesName.push(dataDim); // encodeTooltip.push(dataDim);\n        // encodeLabel.push(dataDim);\n      } // In category way, category axis.\n      else if (coordSysDefine.categoryAxisMap.get(coordDim)) {\n          encode[coordDim] = 0;\n          encodeItemName.push(0);\n        } // In category way, non-category axis.\n        else {\n            var dataDim = datasetRecord.categoryWayDim++;\n            encode[coordDim] = dataDim; // encodeTooltip.push(dataDim);\n            // encodeLabel.push(dataDim);\n\n            encodeSeriesName.push(dataDim);\n          }\n    });\n  } // Do not make a complex rule! Hard to code maintain and not necessary.\n  // ??? TODO refactor: provide by series itself.\n  // [{name: ..., value: ...}, ...] like:\n  else if (nSeriesMap.get(seriesType) != null) {\n      // Find the first not ordinal. (5 is an experience value)\n      var firstNotOrdinal;\n\n      for (var i = 0; i < 5 && firstNotOrdinal == null; i++) {\n        if (!doGuessOrdinal(data, sourceFormat, seriesLayoutBy, completeResult.dimensionsDefine, completeResult.startIndex, i)) {\n          firstNotOrdinal = i;\n        }\n      }\n\n      if (firstNotOrdinal != null) {\n        encode.value = firstNotOrdinal;\n        var nameDimIndex = completeResult.potentialNameDimIndex || Math.max(firstNotOrdinal - 1, 0); // By default, label use itemName in charts.\n        // So we dont set encodeLabel here.\n\n        encodeSeriesName.push(nameDimIndex);\n        encodeItemName.push(nameDimIndex); // encodeTooltip.push(firstNotOrdinal);\n      }\n    } // encodeTooltip.length && (encode.tooltip = encodeTooltip);\n  // encodeLabel.length && (encode.label = encodeLabel);\n\n\n  encodeItemName.length && (encode.itemName = encodeItemName);\n  encodeSeriesName.length && (encode.seriesName = encodeSeriesName);\n  return encode;\n}\n/**\n * If return null/undefined, indicate that should not use datasetModel.\n */\n\n\nfunction getDatasetModel(seriesModel) {\n  var option = seriesModel.option; // Caution: consider the scenario:\n  // A dataset is declared and a series is not expected to use the dataset,\n  // and at the beginning `setOption({series: { noData })` (just prepare other\n  // option but no data), then `setOption({series: {data: [...]}); In this case,\n  // the user should set an empty array to avoid that dataset is used by default.\n\n  var thisData = option.data;\n\n  if (!thisData) {\n    return seriesModel.ecModel.getComponent('dataset', option.datasetIndex || 0);\n  }\n}\n/**\n * The rule should not be complex, otherwise user might not\n * be able to known where the data is wrong.\n * The code is ugly, but how to make it neat?\n *\n * @param {module:echars/data/Source} source\n * @param {number} dimIndex\n * @return {boolean} Whether ordinal.\n */\n\n\nfunction guessOrdinal(source, dimIndex) {\n  return doGuessOrdinal(source.data, source.sourceFormat, source.seriesLayoutBy, source.dimensionsDefine, source.startIndex, dimIndex);\n} // dimIndex may be overflow source data.\n\n\nfunction doGuessOrdinal(data, sourceFormat, seriesLayoutBy, dimensionsDefine, startIndex, dimIndex) {\n  var result; // Experience value.\n\n  var maxLoop = 5;\n\n  if (isTypedArray(data)) {\n    return false;\n  } // When sourceType is 'objectRows' or 'keyedColumns', dimensionsDefine\n  // always exists in source.\n\n\n  var dimName;\n\n  if (dimensionsDefine) {\n    dimName = dimensionsDefine[dimIndex];\n    dimName = isObject(dimName) ? dimName.name : dimName;\n  }\n\n  if (sourceFormat === SOURCE_FORMAT_ARRAY_ROWS) {\n    if (seriesLayoutBy === SERIES_LAYOUT_BY_ROW) {\n      var sample = data[dimIndex];\n\n      for (var i = 0; i < (sample || []).length && i < maxLoop; i++) {\n        if ((result = detectValue(sample[startIndex + i])) != null) {\n          return result;\n        }\n      }\n    } else {\n      for (var i = 0; i < data.length && i < maxLoop; i++) {\n        var row = data[startIndex + i];\n\n        if (row && (result = detectValue(row[dimIndex])) != null) {\n          return result;\n        }\n      }\n    }\n  } else if (sourceFormat === SOURCE_FORMAT_OBJECT_ROWS) {\n    if (!dimName) {\n      return;\n    }\n\n    for (var i = 0; i < data.length && i < maxLoop; i++) {\n      var item = data[i];\n\n      if (item && (result = detectValue(item[dimName])) != null) {\n        return result;\n      }\n    }\n  } else if (sourceFormat === SOURCE_FORMAT_KEYED_COLUMNS) {\n    if (!dimName) {\n      return;\n    }\n\n    var sample = data[dimName];\n\n    if (!sample || isTypedArray(sample)) {\n      return false;\n    }\n\n    for (var i = 0; i < sample.length && i < maxLoop; i++) {\n      if ((result = detectValue(sample[i])) != null) {\n        return result;\n      }\n    }\n  } else if (sourceFormat === SOURCE_FORMAT_ORIGINAL) {\n    for (var i = 0; i < data.length && i < maxLoop; i++) {\n      var item = data[i];\n      var val = getDataItemValue(item);\n\n      if (!isArray(val)) {\n        return false;\n      }\n\n      if ((result = detectValue(val[dimIndex])) != null) {\n        return result;\n      }\n    }\n  }\n\n  function detectValue(val) {\n    // Consider usage convenience, '1', '2' will be treated as \"number\".\n    // `isFinit('')` get `true`.\n    if (val != null && isFinite(val) && val !== '') {\n      return false;\n    } else if (isString(val) && val !== '-') {\n      return true;\n    }\n  }\n\n  return false;\n}\n\nexports.detectSourceFormat = detectSourceFormat;\nexports.getSource = getSource;\nexports.resetSourceDefaulter = resetSourceDefaulter;\nexports.prepareSource = prepareSource;\nexports.guessOrdinal = guessOrdinal;","var g;\r\n\r\n// This works in non-strict mode\r\ng = (function() {\r\n\treturn this;\r\n})();\r\n\r\ntry {\r\n\t// This works if eval is allowed (see CSP)\r\n\tg = g || Function(\"return this\")() || (1, eval)(\"this\");\r\n} catch (e) {\r\n\t// This works if the window reference is available\r\n\tif (typeof window === \"object\") g = window;\r\n}\r\n\r\n// g can still be undefined, but nothing to do about it...\r\n// We return undefined, instead of nothing here, so it's\r\n// easier to handle this case. if(!global) { ...}\r\n\r\nmodule.exports = g;\r\n","\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar _config = require(\"../config\");\n\nvar __DEV__ = _config.__DEV__;\n\nvar _util = require(\"zrender/lib/core/util\");\n\nvar createHashMap = _util.createHashMap;\nvar retrieve = _util.retrieve;\nvar each = _util.each;\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n/**\n * Helper for model references.\n * There are many manners to refer axis/coordSys.\n */\n// TODO\n// merge relevant logic to this file?\n// check: \"modelHelper\" of tooltip and \"BrushTargetManager\".\n\n/**\n * @return {Object} For example:\n * {\n *     coordSysName: 'cartesian2d',\n *     coordSysDims: ['x', 'y', ...],\n *     axisMap: HashMap({\n *         x: xAxisModel,\n *         y: yAxisModel\n *     }),\n *     categoryAxisMap: HashMap({\n *         x: xAxisModel,\n *         y: undefined\n *     }),\n *     // It also indicate that whether there is category axis.\n *     firstCategoryDimIndex: 1,\n *     // To replace user specified encode.\n * }\n */\nfunction getCoordSysDefineBySeries(seriesModel) {\n  var coordSysName = seriesModel.get('coordinateSystem');\n  var result = {\n    coordSysName: coordSysName,\n    coordSysDims: [],\n    axisMap: createHashMap(),\n    categoryAxisMap: createHashMap()\n  };\n  var fetch = fetchers[coordSysName];\n\n  if (fetch) {\n    fetch(seriesModel, result, result.axisMap, result.categoryAxisMap);\n    return result;\n  }\n}\n\nvar fetchers = {\n  cartesian2d: function (seriesModel, result, axisMap, categoryAxisMap) {\n    var xAxisModel = seriesModel.getReferringComponents('xAxis')[0];\n    var yAxisModel = seriesModel.getReferringComponents('yAxis')[0];\n    result.coordSysDims = ['x', 'y'];\n    axisMap.set('x', xAxisModel);\n    axisMap.set('y', yAxisModel);\n\n    if (isCategory(xAxisModel)) {\n      categoryAxisMap.set('x', xAxisModel);\n      result.firstCategoryDimIndex = 0;\n    }\n\n    if (isCategory(yAxisModel)) {\n      categoryAxisMap.set('y', yAxisModel);\n      result.firstCategoryDimIndex = 1;\n    }\n  },\n  singleAxis: function (seriesModel, result, axisMap, categoryAxisMap) {\n    var singleAxisModel = seriesModel.getReferringComponents('singleAxis')[0];\n    result.coordSysDims = ['single'];\n    axisMap.set('single', singleAxisModel);\n\n    if (isCategory(singleAxisModel)) {\n      categoryAxisMap.set('single', singleAxisModel);\n      result.firstCategoryDimIndex = 0;\n    }\n  },\n  polar: function (seriesModel, result, axisMap, categoryAxisMap) {\n    var polarModel = seriesModel.getReferringComponents('polar')[0];\n    var radiusAxisModel = polarModel.findAxisModel('radiusAxis');\n    var angleAxisModel = polarModel.findAxisModel('angleAxis');\n    result.coordSysDims = ['radius', 'angle'];\n    axisMap.set('radius', radiusAxisModel);\n    axisMap.set('angle', angleAxisModel);\n\n    if (isCategory(radiusAxisModel)) {\n      categoryAxisMap.set('radius', radiusAxisModel);\n      result.firstCategoryDimIndex = 0;\n    }\n\n    if (isCategory(angleAxisModel)) {\n      categoryAxisMap.set('angle', angleAxisModel);\n      result.firstCategoryDimIndex = 1;\n    }\n  },\n  geo: function (seriesModel, result, axisMap, categoryAxisMap) {\n    result.coordSysDims = ['lng', 'lat'];\n  },\n  parallel: function (seriesModel, result, axisMap, categoryAxisMap) {\n    var ecModel = seriesModel.ecModel;\n    var parallelModel = ecModel.getComponent('parallel', seriesModel.get('parallelIndex'));\n    var coordSysDims = result.coordSysDims = parallelModel.dimensions.slice();\n    each(parallelModel.parallelAxisIndex, function (axisIndex, index) {\n      var axisModel = ecModel.getComponent('parallelAxis', axisIndex);\n      var axisDim = coordSysDims[index];\n      axisMap.set(axisDim, axisModel);\n\n      if (isCategory(axisModel) && result.firstCategoryDimIndex == null) {\n        categoryAxisMap.set(axisDim, axisModel);\n        result.firstCategoryDimIndex = index;\n      }\n    });\n  }\n};\n\nfunction isCategory(axisModel) {\n  return axisModel.get('type') === 'category';\n}\n\nexports.getCoordSysDefineBySeries = getCoordSysDefineBySeries;","\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar _config = require(\"../config\");\n\nvar __DEV__ = _config.__DEV__;\n\nvar zrUtil = require(\"zrender/lib/core/util\");\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\nvar TYPE_DELIMITER = '.';\nvar IS_CONTAINER = '___EC__COMPONENT__CONTAINER___';\n/**\n * Notice, parseClassType('') should returns {main: '', sub: ''}\n * @public\n */\n\nfunction parseClassType(componentType) {\n  var ret = {\n    main: '',\n    sub: ''\n  };\n\n  if (componentType) {\n    componentType = componentType.split(TYPE_DELIMITER);\n    ret.main = componentType[0] || '';\n    ret.sub = componentType[1] || '';\n  }\n\n  return ret;\n}\n/**\n * @public\n */\n\n\nfunction checkClassType(componentType) {\n  zrUtil.assert(/^[a-zA-Z0-9_]+([.][a-zA-Z0-9_]+)?$/.test(componentType), 'componentType \"' + componentType + '\" illegal');\n}\n/**\n * @public\n */\n\n\nfunction enableClassExtend(RootClass, mandatoryMethods) {\n  RootClass.$constructor = RootClass;\n\n  RootClass.extend = function (proto) {\n    var superClass = this;\n\n    var ExtendedClass = function () {\n      if (!proto.$constructor) {\n        superClass.apply(this, arguments);\n      } else {\n        proto.$constructor.apply(this, arguments);\n      }\n    };\n\n    zrUtil.extend(ExtendedClass.prototype, proto);\n    ExtendedClass.extend = this.extend;\n    ExtendedClass.superCall = superCall;\n    ExtendedClass.superApply = superApply;\n    zrUtil.inherits(ExtendedClass, this);\n    ExtendedClass.superClass = superClass;\n    return ExtendedClass;\n  };\n}\n\nvar classBase = 0;\n/**\n * Can not use instanceof, consider different scope by\n * cross domain or es module import in ec extensions.\n * Mount a method \"isInstance()\" to Clz.\n */\n\nfunction enableClassCheck(Clz) {\n  var classAttr = ['__\\0is_clz', classBase++, Math.random().toFixed(3)].join('_');\n  Clz.prototype[classAttr] = true;\n\n  Clz.isInstance = function (obj) {\n    return !!(obj && obj[classAttr]);\n  };\n} // superCall should have class info, which can not be fetch from 'this'.\n// Consider this case:\n// class A has method f,\n// class B inherits class A, overrides method f, f call superApply('f'),\n// class C inherits class B, do not overrides method f,\n// then when method of class C is called, dead loop occured.\n\n\nfunction superCall(context, methodName) {\n  var args = zrUtil.slice(arguments, 2);\n  return this.superClass.prototype[methodName].apply(context, args);\n}\n\nfunction superApply(context, methodName, args) {\n  return this.superClass.prototype[methodName].apply(context, args);\n}\n/**\n * @param {Object} entity\n * @param {Object} options\n * @param {boolean} [options.registerWhenExtend]\n * @public\n */\n\n\nfunction enableClassManagement(entity, options) {\n  options = options || {};\n  /**\n   * Component model classes\n   * key: componentType,\n   * value:\n   *     componentClass, when componentType is 'xxx'\n   *     or Object.<subKey, componentClass>, when componentType is 'xxx.yy'\n   * @type {Object}\n   */\n\n  var storage = {};\n\n  entity.registerClass = function (Clazz, componentType) {\n    if (componentType) {\n      checkClassType(componentType);\n      componentType = parseClassType(componentType);\n\n      if (!componentType.sub) {\n        storage[componentType.main] = Clazz;\n      } else if (componentType.sub !== IS_CONTAINER) {\n        var container = makeContainer(componentType);\n        container[componentType.sub] = Clazz;\n      }\n    }\n\n    return Clazz;\n  };\n\n  entity.getClass = function (componentMainType, subType, throwWhenNotFound) {\n    var Clazz = storage[componentMainType];\n\n    if (Clazz && Clazz[IS_CONTAINER]) {\n      Clazz = subType ? Clazz[subType] : null;\n    }\n\n    if (throwWhenNotFound && !Clazz) {\n      throw new Error(!subType ? componentMainType + '.' + 'type should be specified.' : 'Component ' + componentMainType + '.' + (subType || '') + ' not exists. Load it first.');\n    }\n\n    return Clazz;\n  };\n\n  entity.getClassesByMainType = function (componentType) {\n    componentType = parseClassType(componentType);\n    var result = [];\n    var obj = storage[componentType.main];\n\n    if (obj && obj[IS_CONTAINER]) {\n      zrUtil.each(obj, function (o, type) {\n        type !== IS_CONTAINER && result.push(o);\n      });\n    } else {\n      result.push(obj);\n    }\n\n    return result;\n  };\n\n  entity.hasClass = function (componentType) {\n    // Just consider componentType.main.\n    componentType = parseClassType(componentType);\n    return !!storage[componentType.main];\n  };\n  /**\n   * @return {Array.<string>} Like ['aa', 'bb'], but can not be ['aa.xx']\n   */\n\n\n  entity.getAllClassMainTypes = function () {\n    var types = [];\n    zrUtil.each(storage, function (obj, type) {\n      types.push(type);\n    });\n    return types;\n  };\n  /**\n   * If a main type is container and has sub types\n   * @param  {string}  mainType\n   * @return {boolean}\n   */\n\n\n  entity.hasSubTypes = function (componentType) {\n    componentType = parseClassType(componentType);\n    var obj = storage[componentType.main];\n    return obj && obj[IS_CONTAINER];\n  };\n\n  entity.parseClassType = parseClassType;\n\n  function makeContainer(componentType) {\n    var container = storage[componentType.main];\n\n    if (!container || !container[IS_CONTAINER]) {\n      container = storage[componentType.main] = {};\n      container[IS_CONTAINER] = true;\n    }\n\n    return container;\n  }\n\n  if (options.registerWhenExtend) {\n    var originalExtend = entity.extend;\n\n    if (originalExtend) {\n      entity.extend = function (proto) {\n        var ExtendedClass = originalExtend.call(this, proto);\n        return entity.registerClass(ExtendedClass, proto.type);\n      };\n    }\n  }\n\n  return entity;\n}\n/**\n * @param {string|Array.<string>} properties\n */\n\n\nfunction setReadOnly(obj, properties) {// FIXME It seems broken in IE8 simulation of IE11\n  // if (!zrUtil.isArray(properties)) {\n  //     properties = properties != null ? [properties] : [];\n  // }\n  // zrUtil.each(properties, function (prop) {\n  //     var value = obj[prop];\n  //     Object.defineProperty\n  //         && Object.defineProperty(obj, prop, {\n  //             value: value, writable: false\n  //         });\n  //     zrUtil.isArray(obj[prop])\n  //         && Object.freeze\n  //         && Object.freeze(obj[prop]);\n  // });\n}\n\nexports.parseClassType = parseClassType;\nexports.enableClassExtend = enableClassExtend;\nexports.enableClassCheck = enableClassCheck;\nexports.enableClassManagement = enableClassManagement;\nexports.setReadOnly = setReadOnly;","\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar _util = require(\"zrender/lib/core/util\");\n\nvar each = _util.each;\nvar createHashMap = _util.createHashMap;\nvar assert = _util.assert;\n\nvar _config = require(\"../../config\");\n\nvar __DEV__ = _config.__DEV__;\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\nvar OTHER_DIMENSIONS = createHashMap(['tooltip', 'label', 'itemName', 'itemId', 'seriesName']);\n\nfunction summarizeDimensions(data) {\n  var summary = {};\n  var encode = summary.encode = {};\n  var notExtraCoordDimMap = createHashMap();\n  var defaultedLabel = [];\n  var defaultedTooltip = [];\n  each(data.dimensions, function (dimName) {\n    var dimItem = data.getDimensionInfo(dimName);\n    var coordDim = dimItem.coordDim;\n\n    if (coordDim) {\n      var coordDimArr = encode[coordDim];\n\n      if (!encode.hasOwnProperty(coordDim)) {\n        coordDimArr = encode[coordDim] = [];\n      }\n\n      coordDimArr[dimItem.coordDimIndex] = dimName;\n\n      if (!dimItem.isExtraCoord) {\n        notExtraCoordDimMap.set(coordDim, 1); // Use the last coord dim (and label friendly) as default label,\n        // because when dataset is used, it is hard to guess which dimension\n        // can be value dimension. If both show x, y on label is not look good,\n        // and conventionally y axis is focused more.\n\n        if (mayLabelDimType(dimItem.type)) {\n          defaultedLabel[0] = dimName;\n        }\n      }\n\n      if (dimItem.defaultTooltip) {\n        defaultedTooltip.push(dimName);\n      }\n    }\n\n    OTHER_DIMENSIONS.each(function (v, otherDim) {\n      var otherDimArr = encode[otherDim];\n\n      if (!encode.hasOwnProperty(otherDim)) {\n        otherDimArr = encode[otherDim] = [];\n      }\n\n      var dimIndex = dimItem.otherDims[otherDim];\n\n      if (dimIndex != null && dimIndex !== false) {\n        otherDimArr[dimIndex] = dimItem.name;\n      }\n    });\n  });\n  var dataDimsOnCoord = [];\n  var encodeFirstDimNotExtra = {};\n  notExtraCoordDimMap.each(function (v, coordDim) {\n    var dimArr = encode[coordDim]; // ??? FIXME extra coord should not be set in dataDimsOnCoord.\n    // But should fix the case that radar axes: simplify the logic\n    // of `completeDimension`, remove `extraPrefix`.\n\n    encodeFirstDimNotExtra[coordDim] = dimArr[0]; // Not necessary to remove duplicate, because a data\n    // dim canot on more than one coordDim.\n\n    dataDimsOnCoord = dataDimsOnCoord.concat(dimArr);\n  });\n  summary.dataDimsOnCoord = dataDimsOnCoord;\n  summary.encodeFirstDimNotExtra = encodeFirstDimNotExtra;\n  var encodeLabel = encode.label; // FIXME `encode.label` is not recommanded, because formatter can not be set\n  // in this way. Use label.formatter instead. May be remove this approach someday.\n\n  if (encodeLabel && encodeLabel.length) {\n    defaultedLabel = encodeLabel.slice();\n  }\n\n  var encodeTooltip = encode.tooltip;\n\n  if (encodeTooltip && encodeTooltip.length) {\n    defaultedTooltip = encodeTooltip.slice();\n  } else if (!defaultedTooltip.length) {\n    defaultedTooltip = defaultedLabel.slice();\n  }\n\n  encode.defaultedLabel = defaultedLabel;\n  encode.defaultedTooltip = defaultedTooltip;\n  return summary;\n}\n\nfunction getDimensionTypeByAxis(axisType) {\n  return axisType === 'category' ? 'ordinal' : axisType === 'time' ? 'time' : 'float';\n}\n\nfunction mayLabelDimType(dimType) {\n  // In most cases, ordinal and time do not suitable for label.\n  // Ordinal info can be displayed on axis. Time is too long.\n  return !(dimType === 'ordinal' || dimType === 'time');\n} // function findTheLastDimMayLabel(data) {\n//     // Get last value dim\n//     var dimensions = data.dimensions.slice();\n//     var valueType;\n//     var valueDim;\n//     while (dimensions.length && (\n//         valueDim = dimensions.pop(),\n//         valueType = data.getDimensionInfo(valueDim).type,\n//         valueType === 'ordinal' || valueType === 'time'\n//     )) {} // jshint ignore:line\n//     return valueDim;\n// }\n\n\nexports.OTHER_DIMENSIONS = OTHER_DIMENSIONS;\nexports.summarizeDimensions = summarizeDimensions;\nexports.getDimensionTypeByAxis = getDimensionTypeByAxis;","var echarts = require('echarts/lib/echarts');\nvar numberUtil = echarts.number;\nvar symbolUtil = require('echarts/lib/util/symbol');\nvar parsePercent = numberUtil.parsePercent;\n\nvar LiquidLayout = require('./liquidFillLayout');\n\nfunction getShallow(model, path) {\n    return model && model.getShallow(path);\n}\n\necharts.extendChartView({\n\n    type: 'liquidFill',\n\n    render: function (seriesModel, ecModel, api) {\n        var group = this.group;\n        group.removeAll();\n\n        var data = seriesModel.getData();\n\n        var itemModel = data.getItemModel(0);\n\n        var center = itemModel.get('center');\n        var radius = itemModel.get('radius');\n\n        var width = api.getWidth();\n        var height = api.getHeight();\n        var size = Math.min(width, height);\n        // itemStyle\n        var outlineDistance = 0;\n        var outlineBorderWidth = 0;\n        var showOutline = seriesModel.get('outline.show');\n\n        if (showOutline) {\n            outlineDistance = seriesModel.get('outline.borderDistance');\n            outlineBorderWidth = parsePercent(\n                seriesModel.get('outline.itemStyle.borderWidth'), size\n            );\n        }\n\n        var cx = parsePercent(center[0], width);\n        var cy = parsePercent(center[1], height);\n\n        var outterRadius;\n        var innerRadius;\n        var paddingRadius;\n\n        var isFillContainer = false;\n\n        var symbol = seriesModel.get('shape');\n        if (symbol === 'container') {\n            // a shape that fully fills the container\n            isFillContainer = true;\n\n            outterRadius = [\n                width / 2,\n                height / 2\n            ];\n            innerRadius = [\n                outterRadius[0] - outlineBorderWidth / 2,\n                outterRadius[1] - outlineBorderWidth / 2\n            ];\n            paddingRadius = [\n                parsePercent(outlineDistance, width),\n                parsePercent(outlineDistance, height)\n            ];\n\n            radius = [\n                Math.max(innerRadius[0] - paddingRadius[0], 0),\n                Math.max(innerRadius[1] - paddingRadius[1], 0)\n            ];\n        }\n        else {\n            outterRadius = parsePercent(radius, size) / 2;\n            innerRadius = outterRadius - outlineBorderWidth / 2;\n            paddingRadius = parsePercent(outlineDistance, size);\n\n            radius = Math.max(innerRadius - paddingRadius, 0);\n        }\n\n        if (showOutline) {\n            var outline = getOutline();\n            outline.style.lineWidth = outlineBorderWidth;\n            group.add(getOutline());\n        }\n\n        var left = isFillContainer ? 0 : cx - radius;\n        var top = isFillContainer ? 0 : cy - radius;\n\n        var wavePath = null;\n\n        group.add(getBackground());\n\n        // each data item for a wave\n        var oldData = this._data;\n        var waves = [];\n        data.diff(oldData)\n            .add(function (idx) {\n                var wave = getWave(idx, false);\n\n                var waterLevel = wave.shape.waterLevel;\n                wave.shape.waterLevel = isFillContainer ? height / 2 : radius;\n                echarts.graphic.initProps(wave, {\n                    shape: {\n                        waterLevel: waterLevel\n                    }\n                }, seriesModel);\n\n                wave.z2 = 2;\n                setWaveAnimation(idx, wave, null);\n\n                group.add(wave);\n                data.setItemGraphicEl(idx, wave);\n                waves.push(wave);\n            })\n            .update(function (newIdx, oldIdx) {\n                var waveElement = oldData.getItemGraphicEl(oldIdx);\n\n                // new wave is used to calculate position, but not added\n                var newWave = getWave(newIdx, false, waveElement);\n\n                // changes with animation\n                var shape = {};\n                var shapeAttrs = ['amplitude', 'cx', 'cy', 'phase', 'radius', 'radiusY', 'waterLevel', 'waveLength'];\n                for (var i = 0; i < shapeAttrs.length; ++i) {\n                    var attr = shapeAttrs[i];\n                    if (newWave.shape.hasOwnProperty(attr)) {\n                        shape[attr] = newWave.shape[attr];\n                    }\n                }\n\n                var style = {};\n                var styleAttrs = ['fill', 'opacity', 'shadowBlur', 'shadowColor'];\n                for (var i = 0; i < styleAttrs.length; ++i) {\n                    var attr = styleAttrs[i];\n                    if (newWave.style.hasOwnProperty(attr)) {\n                        style[attr] = newWave.style[attr];\n                    }\n                }\n\n                if (isFillContainer) {\n                    shape.radiusY = height / 2;\n                }\n\n                // changes with animation\n                echarts.graphic.updateProps(waveElement, {\n                    shape: shape,\n                    style: style\n                }, seriesModel);\n\n                // instant changes\n                waveElement.position = newWave.position;\n                waveElement.setClipPath(newWave.clipPath);\n                waveElement.shape.inverse = newWave.inverse;\n\n                setWaveAnimation(newIdx, waveElement, waveElement);\n                group.add(waveElement);\n                data.setItemGraphicEl(newIdx, waveElement);\n                waves.push(waveElement);\n            })\n            .remove(function (idx) {\n                var wave = oldData.getItemGraphicEl(idx);\n                group.remove(wave);\n            })\n            .execute();\n\n        if (itemModel.get('label.show')) {\n            group.add(getText(waves));\n        }\n\n        this._data = data;\n\n        /**\n         * Get path for outline, background and clipping\n         *\n         * @param {number} r outter radius of shape\n         * @param {boolean|undefined} isForClipping if the shape is used\n         *                                          for clipping\n         */\n        function getPath(r, isForClipping) {\n            if (symbol) {\n                // customed symbol path\n                if (symbol.indexOf('path://') === 0) {\n                    var path = echarts.graphic.makePath(symbol.slice(7), {});\n                    var bouding = path.getBoundingRect();\n                    var w = bouding.width;\n                    var h = bouding.height;\n                    if (w > h) {\n                        h = r * 2 / w * h;\n                        w = r * 2;\n                    }\n                    else {\n                        w = r * 2 / h * w;\n                        h = r * 2;\n                    }\n\n                    var left = isForClipping ? 0 : cx - w / 2;\n                    var top = isForClipping ? 0 : cy - h / 2;\n                    path = echarts.graphic.makePath(\n                        symbol.slice(7),\n                        {},\n                        new echarts.graphic.BoundingRect(left, top, w, h)\n                    );\n                    if (isForClipping) {\n                        path.position = [-w / 2, -h / 2];\n                    }\n                    return path;\n                }\n                else if (isFillContainer) {\n                    // fully fill the container\n                    var x = isForClipping ? -r[0] : cx - r[0];\n                    var y = isForClipping ? -r[1] : cy - r[1];\n                    return symbolUtil.createSymbol(\n                        'rect', x, y, r[0] * 2, r[1] * 2\n                    );\n                }\n                else {\n                    var x = isForClipping ? -r : cx - r;\n                    var y = isForClipping ? -r : cy - r;\n                    if (symbol === 'pin') {\n                        y += r;\n                    }\n                    else if (symbol === 'arrow') {\n                        y -= r;\n                    }\n                    return symbolUtil.createSymbol(symbol, x, y, r * 2, r * 2);\n                }\n            }\n\n            return new echarts.graphic.Circle({\n                shape: {\n                    cx: isForClipping ? 0 : cx,\n                    cy: isForClipping ? 0 : cy,\n                    r: r\n                }\n            });\n        }\n        /**\n         * Create outline\n         */\n        function getOutline() {\n            var outlinePath = getPath(outterRadius);\n            outlinePath.style.fill = null;\n\n            outlinePath.setStyle(seriesModel.getModel('outline.itemStyle')\n                .getItemStyle());\n\n            return outlinePath;\n        }\n\n        /**\n         * Create background\n         */\n        function getBackground() {\n            // Seperate stroke and fill, so we can use stroke to cover the alias of clipping.\n            var strokePath = getPath(radius);\n            strokePath.setStyle(seriesModel.getModel('backgroundStyle')\n                .getItemStyle());\n            strokePath.style.fill = null;\n\n            // Stroke is front of wave\n            strokePath.z2 = 5;\n\n            var fillPath = getPath(radius);\n            fillPath.setStyle(seriesModel.getModel('backgroundStyle')\n                .getItemStyle());\n            fillPath.style.stroke = null;\n\n            var group = new echarts.graphic.Group();\n            group.add(strokePath);\n            group.add(fillPath);\n\n            return group;\n        }\n\n        /**\n         * wave shape\n         */\n        function getWave(idx, isInverse, oldWave) {\n            var radiusX = isFillContainer ? radius[0] : radius;\n            var radiusY = isFillContainer ? height / 2 : radius;\n\n            var itemModel = data.getItemModel(idx);\n            var itemStyleModel = itemModel.getModel('itemStyle');\n            var phase = itemModel.get('phase');\n            var amplitude = parsePercent(itemModel.get('amplitude'),\n                radiusY * 2);\n            var waveLength = parsePercent(itemModel.get('waveLength'),\n                radiusX * 2);\n\n            var value = data.get('value', idx);\n            var waterLevel = radiusY - value * radiusY * 2;\n            phase = oldWave ? oldWave.shape.phase\n                : (phase === 'auto' ? idx * Math.PI / 4 : phase);\n            var normalStyle = itemStyleModel.getItemStyle();\n            if (!normalStyle.fill) {\n                var seriesColor = seriesModel.get('color');\n                var id = idx % seriesColor.length;\n                normalStyle.fill = seriesColor[id];\n            }\n\n            var x = radiusX * 2;\n            var wave = new LiquidLayout({\n                shape: {\n                    waveLength: waveLength,\n                    radius: radiusX,\n                    radiusY: radiusY,\n                    cx: x,\n                    cy: 0,\n                    waterLevel: waterLevel,\n                    amplitude: amplitude,\n                    phase: phase,\n                    inverse: isInverse\n                },\n                style: normalStyle,\n                position: [cx, cy]\n            });\n            wave.shape._waterLevel = waterLevel;\n\n            var hoverStyle = itemModel.getModel('emphasis.itemStyle')\n                .getItemStyle();\n            hoverStyle.lineWidth = 0;\n            echarts.graphic.setHoverStyle(wave, hoverStyle);\n\n            // clip out the part outside the circle\n            var clip = getPath(radius, true);\n            // set fill for clipPath, otherwise it will not trigger hover event\n            clip.setStyle({\n                fill: 'white'\n            });\n            wave.setClipPath(clip);\n\n            return wave;\n        }\n\n        function setWaveAnimation(idx, wave, oldWave) {\n            var itemModel = data.getItemModel(idx);\n\n            var maxSpeed = itemModel.get('period');\n            var direction = itemModel.get('direction');\n\n            var value = data.get('value', idx);\n\n            var phase = itemModel.get('phase');\n            phase = oldWave ? oldWave.shape.phase\n                : (phase === 'auto' ? idx * Math.PI / 4 : phase);\n\n            var defaultSpeed = function (maxSpeed) {\n                var cnt = data.count();\n                return cnt === 0 ? maxSpeed : maxSpeed *\n                    (0.2 + (cnt - idx) / cnt * 0.8);\n            };\n            var speed = 0;\n            if (maxSpeed === 'auto') {\n                speed = defaultSpeed(5000);\n            }\n            else {\n                speed = typeof maxSpeed === 'function'\n                    ? maxSpeed(value, idx) : maxSpeed;\n            }\n\n            // phase for moving left/right\n            var phaseOffset = 0;\n            if (direction === 'right' || direction == null) {\n                phaseOffset = Math.PI;\n            }\n            else if (direction === 'left') {\n                phaseOffset = -Math.PI;\n            }\n            else if (direction === 'none') {\n                phaseOffset = 0;\n            }\n            else {\n                console.error('Illegal direction value for liquid fill.');\n            }\n\n            // wave animation of moving left/right\n            if (direction !== 'none' && itemModel.get('waveAnimation')) {\n                wave\n                    .animate('shape', true)\n                    .when(0, {\n                        phase: phase\n                    })\n                    .when(speed / 2, {\n                        phase: phaseOffset + phase\n                    })\n                    .when(speed, {\n                        phase: phaseOffset * 2 + phase\n                    })\n                    .during(function () {\n                        if (wavePath) {\n                            wavePath.dirty(true);\n                        }\n                    })\n                    .start();\n            }\n        }\n\n        /**\n         * text on wave\n         */\n        function getText(waves) {\n            var labelModel = itemModel.getModel('label');\n\n            function formatLabel() {\n                var formatted = seriesModel.getFormattedLabel(0, 'normal');\n                var defaultVal = (data.get('value', 0) * 100);\n                var defaultLabel = data.getName(0) || seriesModel.name;\n                if (!isNaN(defaultVal)) {\n                    defaultLabel = defaultVal.toFixed(0) + '%';\n                }\n                return formatted == null ? defaultLabel : formatted;\n            }\n\n            var textOption = {\n                z2: 10,\n                shape: {\n                    x: left,\n                    y: top,\n                    width: (isFillContainer ? radius[0] : radius) * 2,\n                    height: (isFillContainer ? radius[1] : radius) * 2\n                },\n                style: {\n                    fill: 'transparent',\n                    text: formatLabel(),\n                    textAlign: labelModel.get('align'),\n                    textVerticalAlign: labelModel.get('baseline')\n                },\n                silent: true\n            };\n\n            var outsideTextRect = new echarts.graphic.Rect(textOption);\n            var color = labelModel.get('color');\n            echarts.graphic.setText(outsideTextRect.style, labelModel, color);\n\n            var insideTextRect = new echarts.graphic.Rect(textOption);\n            var insColor = labelModel.get('insideColor');\n            echarts.graphic.setText(insideTextRect.style, labelModel, insColor);\n            insideTextRect.style.textFill = insColor;\n\n            var group = new echarts.graphic.Group();\n            group.add(outsideTextRect);\n            group.add(insideTextRect);\n\n            // clip out waves for insideText\n            var boundingCircle = getPath(radius, true);\n\n            wavePath = new echarts.graphic.CompoundPath({\n                shape: {\n                    paths: waves\n                },\n                position: [cx, cy]\n            });\n\n            wavePath.setClipPath(boundingCircle);\n            insideTextRect.setClipPath(wavePath);\n\n            return group;\n        }\n    },\n\n    dispose: function () {\n        // dispose nothing here\n    }\n});\n","\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar zrUtil = require(\"zrender/lib/core/util\");\n\nvar graphic = require(\"./graphic\");\n\nvar BoundingRect = require(\"zrender/lib/core/BoundingRect\");\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n// Symbol factory\n\n/**\n * Triangle shape\n * @inner\n */\nvar Triangle = graphic.extendShape({\n  type: 'triangle',\n  shape: {\n    cx: 0,\n    cy: 0,\n    width: 0,\n    height: 0\n  },\n  buildPath: function (path, shape) {\n    var cx = shape.cx;\n    var cy = shape.cy;\n    var width = shape.width / 2;\n    var height = shape.height / 2;\n    path.moveTo(cx, cy - height);\n    path.lineTo(cx + width, cy + height);\n    path.lineTo(cx - width, cy + height);\n    path.closePath();\n  }\n});\n/**\n * Diamond shape\n * @inner\n */\n\nvar Diamond = graphic.extendShape({\n  type: 'diamond',\n  shape: {\n    cx: 0,\n    cy: 0,\n    width: 0,\n    height: 0\n  },\n  buildPath: function (path, shape) {\n    var cx = shape.cx;\n    var cy = shape.cy;\n    var width = shape.width / 2;\n    var height = shape.height / 2;\n    path.moveTo(cx, cy - height);\n    path.lineTo(cx + width, cy);\n    path.lineTo(cx, cy + height);\n    path.lineTo(cx - width, cy);\n    path.closePath();\n  }\n});\n/**\n * Pin shape\n * @inner\n */\n\nvar Pin = graphic.extendShape({\n  type: 'pin',\n  shape: {\n    // x, y on the cusp\n    x: 0,\n    y: 0,\n    width: 0,\n    height: 0\n  },\n  buildPath: function (path, shape) {\n    var x = shape.x;\n    var y = shape.y;\n    var w = shape.width / 5 * 3; // Height must be larger than width\n\n    var h = Math.max(w, shape.height);\n    var r = w / 2; // Dist on y with tangent point and circle center\n\n    var dy = r * r / (h - r);\n    var cy = y - h + r + dy;\n    var angle = Math.asin(dy / r); // Dist on x with tangent point and circle center\n\n    var dx = Math.cos(angle) * r;\n    var tanX = Math.sin(angle);\n    var tanY = Math.cos(angle);\n    var cpLen = r * 0.6;\n    var cpLen2 = r * 0.7;\n    path.moveTo(x - dx, cy + dy);\n    path.arc(x, cy, r, Math.PI - angle, Math.PI * 2 + angle);\n    path.bezierCurveTo(x + dx - tanX * cpLen, cy + dy + tanY * cpLen, x, y - cpLen2, x, y);\n    path.bezierCurveTo(x, y - cpLen2, x - dx + tanX * cpLen, cy + dy + tanY * cpLen, x - dx, cy + dy);\n    path.closePath();\n  }\n});\n/**\n * Arrow shape\n * @inner\n */\n\nvar Arrow = graphic.extendShape({\n  type: 'arrow',\n  shape: {\n    x: 0,\n    y: 0,\n    width: 0,\n    height: 0\n  },\n  buildPath: function (ctx, shape) {\n    var height = shape.height;\n    var width = shape.width;\n    var x = shape.x;\n    var y = shape.y;\n    var dx = width / 3 * 2;\n    ctx.moveTo(x, y);\n    ctx.lineTo(x + dx, y + height);\n    ctx.lineTo(x, y + height / 4 * 3);\n    ctx.lineTo(x - dx, y + height);\n    ctx.lineTo(x, y);\n    ctx.closePath();\n  }\n});\n/**\n * Map of path contructors\n * @type {Object.<string, module:zrender/graphic/Path>}\n */\n\nvar symbolCtors = {\n  line: graphic.Line,\n  rect: graphic.Rect,\n  roundRect: graphic.Rect,\n  square: graphic.Rect,\n  circle: graphic.Circle,\n  diamond: Diamond,\n  pin: Pin,\n  arrow: Arrow,\n  triangle: Triangle\n};\nvar symbolShapeMakers = {\n  line: function (x, y, w, h, shape) {\n    // FIXME\n    shape.x1 = x;\n    shape.y1 = y + h / 2;\n    shape.x2 = x + w;\n    shape.y2 = y + h / 2;\n  },\n  rect: function (x, y, w, h, shape) {\n    shape.x = x;\n    shape.y = y;\n    shape.width = w;\n    shape.height = h;\n  },\n  roundRect: function (x, y, w, h, shape) {\n    shape.x = x;\n    shape.y = y;\n    shape.width = w;\n    shape.height = h;\n    shape.r = Math.min(w, h) / 4;\n  },\n  square: function (x, y, w, h, shape) {\n    var size = Math.min(w, h);\n    shape.x = x;\n    shape.y = y;\n    shape.width = size;\n    shape.height = size;\n  },\n  circle: function (x, y, w, h, shape) {\n    // Put circle in the center of square\n    shape.cx = x + w / 2;\n    shape.cy = y + h / 2;\n    shape.r = Math.min(w, h) / 2;\n  },\n  diamond: function (x, y, w, h, shape) {\n    shape.cx = x + w / 2;\n    shape.cy = y + h / 2;\n    shape.width = w;\n    shape.height = h;\n  },\n  pin: function (x, y, w, h, shape) {\n    shape.x = x + w / 2;\n    shape.y = y + h / 2;\n    shape.width = w;\n    shape.height = h;\n  },\n  arrow: function (x, y, w, h, shape) {\n    shape.x = x + w / 2;\n    shape.y = y + h / 2;\n    shape.width = w;\n    shape.height = h;\n  },\n  triangle: function (x, y, w, h, shape) {\n    shape.cx = x + w / 2;\n    shape.cy = y + h / 2;\n    shape.width = w;\n    shape.height = h;\n  }\n};\nvar symbolBuildProxies = {};\nzrUtil.each(symbolCtors, function (Ctor, name) {\n  symbolBuildProxies[name] = new Ctor();\n});\nvar SymbolClz = graphic.extendShape({\n  type: 'symbol',\n  shape: {\n    symbolType: '',\n    x: 0,\n    y: 0,\n    width: 0,\n    height: 0\n  },\n  beforeBrush: function () {\n    var style = this.style;\n    var shape = this.shape; // FIXME\n\n    if (shape.symbolType === 'pin' && style.textPosition === 'inside') {\n      style.textPosition = ['50%', '40%'];\n      style.textAlign = 'center';\n      style.textVerticalAlign = 'middle';\n    }\n  },\n  buildPath: function (ctx, shape, inBundle) {\n    var symbolType = shape.symbolType;\n    var proxySymbol = symbolBuildProxies[symbolType];\n\n    if (shape.symbolType !== 'none') {\n      if (!proxySymbol) {\n        // Default rect\n        symbolType = 'rect';\n        proxySymbol = symbolBuildProxies[symbolType];\n      }\n\n      symbolShapeMakers[symbolType](shape.x, shape.y, shape.width, shape.height, proxySymbol.shape);\n      proxySymbol.buildPath(ctx, proxySymbol.shape, inBundle);\n    }\n  }\n}); // Provide setColor helper method to avoid determine if set the fill or stroke outside\n\nfunction symbolPathSetColor(color, innerColor) {\n  if (this.type !== 'image') {\n    var symbolStyle = this.style;\n    var symbolShape = this.shape;\n\n    if (symbolShape && symbolShape.symbolType === 'line') {\n      symbolStyle.stroke = color;\n    } else if (this.__isEmptyBrush) {\n      symbolStyle.stroke = color;\n      symbolStyle.fill = innerColor || '#fff';\n    } else {\n      // FIXME 判断图形默认是填充还是描边，使用 onlyStroke ?\n      symbolStyle.fill && (symbolStyle.fill = color);\n      symbolStyle.stroke && (symbolStyle.stroke = color);\n    }\n\n    this.dirty(false);\n  }\n}\n/**\n * Create a symbol element with given symbol configuration: shape, x, y, width, height, color\n * @param {string} symbolType\n * @param {number} x\n * @param {number} y\n * @param {number} w\n * @param {number} h\n * @param {string} color\n * @param {boolean} [keepAspect=false] whether to keep the ratio of w/h,\n *                            for path and image only.\n */\n\n\nfunction createSymbol(symbolType, x, y, w, h, color, keepAspect) {\n  // TODO Support image object, DynamicImage.\n  var isEmpty = symbolType.indexOf('empty') === 0;\n\n  if (isEmpty) {\n    symbolType = symbolType.substr(5, 1).toLowerCase() + symbolType.substr(6);\n  }\n\n  var symbolPath;\n\n  if (symbolType.indexOf('image://') === 0) {\n    symbolPath = graphic.makeImage(symbolType.slice(8), new BoundingRect(x, y, w, h), keepAspect ? 'center' : 'cover');\n  } else if (symbolType.indexOf('path://') === 0) {\n    symbolPath = graphic.makePath(symbolType.slice(7), {}, new BoundingRect(x, y, w, h), keepAspect ? 'center' : 'cover');\n  } else {\n    symbolPath = new SymbolClz({\n      shape: {\n        symbolType: symbolType,\n        x: x,\n        y: y,\n        width: w,\n        height: h\n      }\n    });\n  }\n\n  symbolPath.__isEmptyBrush = isEmpty;\n  symbolPath.setColor = symbolPathSetColor;\n  symbolPath.setColor(color);\n  return symbolPath;\n}\n\nexports.createSymbol = createSymbol;","\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar zrUtil = require(\"zrender/lib/core/util\");\n\nvar pathTool = require(\"zrender/lib/tool/path\");\n\nvar colorTool = require(\"zrender/lib/tool/color\");\n\nvar matrix = require(\"zrender/lib/core/matrix\");\n\nvar vector = require(\"zrender/lib/core/vector\");\n\nvar Path = require(\"zrender/lib/graphic/Path\");\n\nvar Transformable = require(\"zrender/lib/mixin/Transformable\");\n\nvar ZImage = require(\"zrender/lib/graphic/Image\");\n\nexports.Image = ZImage;\n\nvar Group = require(\"zrender/lib/container/Group\");\n\nexports.Group = Group;\n\nvar Text = require(\"zrender/lib/graphic/Text\");\n\nexports.Text = Text;\n\nvar Circle = require(\"zrender/lib/graphic/shape/Circle\");\n\nexports.Circle = Circle;\n\nvar Sector = require(\"zrender/lib/graphic/shape/Sector\");\n\nexports.Sector = Sector;\n\nvar Ring = require(\"zrender/lib/graphic/shape/Ring\");\n\nexports.Ring = Ring;\n\nvar Polygon = require(\"zrender/lib/graphic/shape/Polygon\");\n\nexports.Polygon = Polygon;\n\nvar Polyline = require(\"zrender/lib/graphic/shape/Polyline\");\n\nexports.Polyline = Polyline;\n\nvar Rect = require(\"zrender/lib/graphic/shape/Rect\");\n\nexports.Rect = Rect;\n\nvar Line = require(\"zrender/lib/graphic/shape/Line\");\n\nexports.Line = Line;\n\nvar BezierCurve = require(\"zrender/lib/graphic/shape/BezierCurve\");\n\nexports.BezierCurve = BezierCurve;\n\nvar Arc = require(\"zrender/lib/graphic/shape/Arc\");\n\nexports.Arc = Arc;\n\nvar CompoundPath = require(\"zrender/lib/graphic/CompoundPath\");\n\nexports.CompoundPath = CompoundPath;\n\nvar LinearGradient = require(\"zrender/lib/graphic/LinearGradient\");\n\nexports.LinearGradient = LinearGradient;\n\nvar RadialGradient = require(\"zrender/lib/graphic/RadialGradient\");\n\nexports.RadialGradient = RadialGradient;\n\nvar BoundingRect = require(\"zrender/lib/core/BoundingRect\");\n\nexports.BoundingRect = BoundingRect;\n\nvar IncrementalDisplayable = require(\"zrender/lib/graphic/IncrementalDisplayable\");\n\nexports.IncrementalDisplayable = IncrementalDisplayable;\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\nvar round = Math.round;\nvar mathMax = Math.max;\nvar mathMin = Math.min;\nvar EMPTY_OBJ = {};\nvar Z2_EMPHASIS_LIFT = 1;\n/**\n * Extend shape with parameters\n */\n\nfunction extendShape(opts) {\n  return Path.extend(opts);\n}\n/**\n * Extend path\n */\n\n\nfunction extendPath(pathData, opts) {\n  return pathTool.extendFromString(pathData, opts);\n}\n/**\n * Create a path element from path data string\n * @param {string} pathData\n * @param {Object} opts\n * @param {module:zrender/core/BoundingRect} rect\n * @param {string} [layout=cover] 'center' or 'cover'\n */\n\n\nfunction makePath(pathData, opts, rect, layout) {\n  var path = pathTool.createFromString(pathData, opts);\n\n  if (rect) {\n    if (layout === 'center') {\n      rect = centerGraphic(rect, path.getBoundingRect());\n    }\n\n    resizePath(path, rect);\n  }\n\n  return path;\n}\n/**\n * Create a image element from image url\n * @param {string} imageUrl image url\n * @param {Object} opts options\n * @param {module:zrender/core/BoundingRect} rect constrain rect\n * @param {string} [layout=cover] 'center' or 'cover'\n */\n\n\nfunction makeImage(imageUrl, rect, layout) {\n  var path = new ZImage({\n    style: {\n      image: imageUrl,\n      x: rect.x,\n      y: rect.y,\n      width: rect.width,\n      height: rect.height\n    },\n    onload: function (img) {\n      if (layout === 'center') {\n        var boundingRect = {\n          width: img.width,\n          height: img.height\n        };\n        path.setStyle(centerGraphic(rect, boundingRect));\n      }\n    }\n  });\n  return path;\n}\n/**\n * Get position of centered element in bounding box.\n *\n * @param  {Object} rect         element local bounding box\n * @param  {Object} boundingRect constraint bounding box\n * @return {Object} element position containing x, y, width, and height\n */\n\n\nfunction centerGraphic(rect, boundingRect) {\n  // Set rect to center, keep width / height ratio.\n  var aspect = boundingRect.width / boundingRect.height;\n  var width = rect.height * aspect;\n  var height;\n\n  if (width <= rect.width) {\n    height = rect.height;\n  } else {\n    width = rect.width;\n    height = width / aspect;\n  }\n\n  var cx = rect.x + rect.width / 2;\n  var cy = rect.y + rect.height / 2;\n  return {\n    x: cx - width / 2,\n    y: cy - height / 2,\n    width: width,\n    height: height\n  };\n}\n\nvar mergePath = pathTool.mergePath;\n/**\n * Resize a path to fit the rect\n * @param {module:zrender/graphic/Path} path\n * @param {Object} rect\n */\n\nfunction resizePath(path, rect) {\n  if (!path.applyTransform) {\n    return;\n  }\n\n  var pathRect = path.getBoundingRect();\n  var m = pathRect.calculateTransform(rect);\n  path.applyTransform(m);\n}\n/**\n * Sub pixel optimize line for canvas\n *\n * @param {Object} param\n * @param {Object} [param.shape]\n * @param {number} [param.shape.x1]\n * @param {number} [param.shape.y1]\n * @param {number} [param.shape.x2]\n * @param {number} [param.shape.y2]\n * @param {Object} [param.style]\n * @param {number} [param.style.lineWidth]\n * @return {Object} Modified param\n */\n\n\nfunction subPixelOptimizeLine(param) {\n  var shape = param.shape;\n  var lineWidth = param.style.lineWidth;\n\n  if (round(shape.x1 * 2) === round(shape.x2 * 2)) {\n    shape.x1 = shape.x2 = subPixelOptimize(shape.x1, lineWidth, true);\n  }\n\n  if (round(shape.y1 * 2) === round(shape.y2 * 2)) {\n    shape.y1 = shape.y2 = subPixelOptimize(shape.y1, lineWidth, true);\n  }\n\n  return param;\n}\n/**\n * Sub pixel optimize rect for canvas\n *\n * @param {Object} param\n * @param {Object} [param.shape]\n * @param {number} [param.shape.x]\n * @param {number} [param.shape.y]\n * @param {number} [param.shape.width]\n * @param {number} [param.shape.height]\n * @param {Object} [param.style]\n * @param {number} [param.style.lineWidth]\n * @return {Object} Modified param\n */\n\n\nfunction subPixelOptimizeRect(param) {\n  var shape = param.shape;\n  var lineWidth = param.style.lineWidth;\n  var originX = shape.x;\n  var originY = shape.y;\n  var originWidth = shape.width;\n  var originHeight = shape.height;\n  shape.x = subPixelOptimize(shape.x, lineWidth, true);\n  shape.y = subPixelOptimize(shape.y, lineWidth, true);\n  shape.width = Math.max(subPixelOptimize(originX + originWidth, lineWidth, false) - shape.x, originWidth === 0 ? 0 : 1);\n  shape.height = Math.max(subPixelOptimize(originY + originHeight, lineWidth, false) - shape.y, originHeight === 0 ? 0 : 1);\n  return param;\n}\n/**\n * Sub pixel optimize for canvas\n *\n * @param {number} position Coordinate, such as x, y\n * @param {number} lineWidth Should be nonnegative integer.\n * @param {boolean=} positiveOrNegative Default false (negative).\n * @return {number} Optimized position.\n */\n\n\nfunction subPixelOptimize(position, lineWidth, positiveOrNegative) {\n  // Assure that (position + lineWidth / 2) is near integer edge,\n  // otherwise line will be fuzzy in canvas.\n  var doubledPosition = round(position * 2);\n  return (doubledPosition + round(lineWidth)) % 2 === 0 ? doubledPosition / 2 : (doubledPosition + (positiveOrNegative ? 1 : -1)) / 2;\n}\n\nfunction hasFillOrStroke(fillOrStroke) {\n  return fillOrStroke != null && fillOrStroke !== 'none';\n} // Most lifted color are duplicated.\n\n\nvar liftedColorMap = zrUtil.createHashMap();\nvar liftedColorCount = 0;\n\nfunction liftColor(color) {\n  if (typeof color !== 'string') {\n    return color;\n  }\n\n  var liftedColor = liftedColorMap.get(color);\n\n  if (!liftedColor) {\n    liftedColor = colorTool.lift(color, -0.1);\n\n    if (liftedColorCount < 10000) {\n      liftedColorMap.set(color, liftedColor);\n      liftedColorCount++;\n    }\n  }\n\n  return liftedColor;\n}\n\nfunction cacheElementStl(el) {\n  if (!el.__hoverStlDirty) {\n    return;\n  }\n\n  el.__hoverStlDirty = false;\n  var hoverStyle = el.__hoverStl;\n\n  if (!hoverStyle) {\n    el.__cachedNormalStl = el.__cachedNormalZ2 = null;\n    return;\n  }\n\n  var normalStyle = el.__cachedNormalStl = {};\n  el.__cachedNormalZ2 = el.z2;\n  var elStyle = el.style;\n\n  for (var name in hoverStyle) {\n    // See comment in `doSingleEnterHover`.\n    if (hoverStyle[name] != null) {\n      normalStyle[name] = elStyle[name];\n    }\n  } // Always cache fill and stroke to normalStyle for lifting color.\n\n\n  normalStyle.fill = elStyle.fill;\n  normalStyle.stroke = elStyle.stroke;\n}\n\nfunction doSingleEnterHover(el) {\n  var hoverStl = el.__hoverStl;\n\n  if (!hoverStl || el.__highlighted) {\n    return;\n  }\n\n  var useHoverLayer = el.useHoverLayer;\n  el.__highlighted = useHoverLayer ? 'layer' : 'plain';\n  var zr = el.__zr;\n\n  if (!zr && useHoverLayer) {\n    return;\n  }\n\n  var elTarget = el;\n  var targetStyle = el.style;\n\n  if (useHoverLayer) {\n    elTarget = zr.addHover(el);\n    targetStyle = elTarget.style;\n  }\n\n  rollbackDefaultTextStyle(targetStyle);\n\n  if (!useHoverLayer) {\n    cacheElementStl(elTarget);\n  } // styles can be:\n  // {\n  //    label: {\n  //        show: false,\n  //        position: 'outside',\n  //        fontSize: 18\n  //    },\n  //    emphasis: {\n  //        label: {\n  //            show: true\n  //        }\n  //    }\n  // },\n  // where properties of `emphasis` may not appear in `normal`. We previously use\n  // module:echarts/util/model#defaultEmphasis to merge `normal` to `emphasis`.\n  // But consider rich text and setOption in merge mode, it is impossible to cover\n  // all properties in merge. So we use merge mode when setting style here, where\n  // only properties that is not `null/undefined` can be set. The disadventage:\n  // null/undefined can not be used to remove style any more in `emphasis`.\n\n\n  targetStyle.extendFrom(hoverStl);\n  setDefaultHoverFillStroke(targetStyle, hoverStl, 'fill');\n  setDefaultHoverFillStroke(targetStyle, hoverStl, 'stroke');\n  applyDefaultTextStyle(targetStyle);\n\n  if (!useHoverLayer) {\n    el.dirty(false);\n    el.z2 += Z2_EMPHASIS_LIFT;\n  }\n}\n\nfunction setDefaultHoverFillStroke(targetStyle, hoverStyle, prop) {\n  if (!hasFillOrStroke(hoverStyle[prop]) && hasFillOrStroke(targetStyle[prop])) {\n    targetStyle[prop] = liftColor(targetStyle[prop]);\n  }\n}\n\nfunction doSingleLeaveHover(el) {\n  var highlighted = el.__highlighted;\n\n  if (!highlighted) {\n    return;\n  }\n\n  el.__highlighted = false;\n\n  if (highlighted === 'layer') {\n    el.__zr && el.__zr.removeHover(el);\n  } else if (highlighted) {\n    var style = el.style;\n    var normalStl = el.__cachedNormalStl;\n\n    if (normalStl) {\n      rollbackDefaultTextStyle(style); // Consider null/undefined value, should use\n      // `setStyle` but not `extendFrom(stl, true)`.\n\n      el.setStyle(normalStl);\n      applyDefaultTextStyle(style);\n    } // `__cachedNormalZ2` will not be reset if calling `setElementHoverStyle`\n    // when `el` is on emphasis state. So here by comparing with 1, we try\n    // hard to make the bug case rare.\n\n\n    var normalZ2 = el.__cachedNormalZ2;\n\n    if (normalZ2 != null && el.z2 - normalZ2 === Z2_EMPHASIS_LIFT) {\n      el.z2 = normalZ2;\n    }\n  }\n}\n\nfunction traverseCall(el, method) {\n  el.isGroup ? el.traverse(function (child) {\n    !child.isGroup && method(child);\n  }) : method(el);\n}\n/**\n * Set hover style (namely \"emphasis style\") of element, based on the current\n * style of the given `el`.\n * This method should be called after all of the normal styles have been adopted\n * to the `el`. See the reason on `setHoverStyle`.\n *\n * @param {module:zrender/Element} el Should not be `zrender/container/Group`.\n * @param {Object|boolean} [hoverStl] The specified hover style.\n *        If set as `false`, disable the hover style.\n *        Similarly, The `el.hoverStyle` can alse be set\n *        as `false` to disable the hover style.\n *        Otherwise, use the default hover style if not provided.\n * @param {Object} [opt]\n * @param {boolean} [opt.hoverSilentOnTouch=false] See `graphic.setAsHoverStyleTrigger`\n */\n\n\nfunction setElementHoverStyle(el, hoverStl) {\n  // For performance consideration, it might be better to make the \"hover style\" only the\n  // difference properties from the \"normal style\", but not a entire copy of all styles.\n  hoverStl = el.__hoverStl = hoverStl !== false && (hoverStl || {});\n  el.__hoverStlDirty = true; // FIXME\n  // It is not completely right to save \"normal\"/\"emphasis\" flag on elements.\n  // It probably should be saved on `data` of series. Consider the cases:\n  // (1) A highlighted elements are moved out of the view port and re-enter\n  // again by dataZoom.\n  // (2) call `setOption` and replace elements totally when they are highlighted.\n\n  if (el.__highlighted) {\n    // Consider the case:\n    // The styles of a highlighted `el` is being updated. The new \"emphasis style\"\n    // should be adapted to the `el`. Notice here new \"normal styles\" should have\n    // been set outside and the cached \"normal style\" is out of date.\n    el.__cachedNormalStl = null; // Do not clear `__cachedNormalZ2` here, because setting `z2` is not a constraint\n    // of this method. In most cases, `z2` is not set and hover style should be able\n    // to rollback. Of course, that would bring bug, but only in a rare case, see\n    // `doSingleLeaveHover` for details.\n\n    doSingleLeaveHover(el);\n    doSingleEnterHover(el);\n  }\n}\n/**\n * Emphasis (called by API) has higher priority than `mouseover`.\n * When element has been called to be entered emphasis, mouse over\n * should not trigger the highlight effect (for example, animation\n * scale) again, and `mouseout` should not downplay the highlight\n * effect. So the listener of `mouseover` and `mouseout` should\n * check `isInEmphasis`.\n *\n * @param {module:zrender/Element} el\n * @return {boolean}\n */\n\n\nfunction isInEmphasis(el) {\n  return el && el.__isEmphasisEntered;\n}\n\nfunction onElementMouseOver(e) {\n  if (this.__hoverSilentOnTouch && e.zrByTouch) {\n    return;\n  } // Only if element is not in emphasis status\n\n\n  !this.__isEmphasisEntered && traverseCall(this, doSingleEnterHover);\n}\n\nfunction onElementMouseOut(e) {\n  if (this.__hoverSilentOnTouch && e.zrByTouch) {\n    return;\n  } // Only if element is not in emphasis status\n\n\n  !this.__isEmphasisEntered && traverseCall(this, doSingleLeaveHover);\n}\n\nfunction enterEmphasis() {\n  this.__isEmphasisEntered = true;\n  traverseCall(this, doSingleEnterHover);\n}\n\nfunction leaveEmphasis() {\n  this.__isEmphasisEntered = false;\n  traverseCall(this, doSingleLeaveHover);\n}\n/**\n * Set hover style (namely \"emphasis style\") of element,\n * based on the current style of the given `el`.\n *\n * (1)\n * **CONSTRAINTS** for this method:\n * <A> This method MUST be called after all of the normal styles having been adopted\n * to the `el`.\n * <B> The input `hoverStyle` (that is, \"emphasis style\") MUST be the subset of the\n * \"normal style\" having been set to the el.\n * <C> `color` MUST be one of the \"normal styles\" (because color might be lifted as\n * a default hover style).\n *\n * The reason: this method treat the current style of the `el` as the \"normal style\"\n * and cache them when enter/update the \"emphasis style\". Consider the case: the `el`\n * is in \"emphasis\" state and `setOption`/`dispatchAction` trigger the style updating\n * logic, where the el should shift from the original emphasis style to the new\n * \"emphasis style\" and should be able to \"downplay\" back to the new \"normal style\".\n *\n * Indeed, it is error-prone to make a interface has so many constraints, but I have\n * not found a better solution yet to fit the backward compatibility, performance and\n * the current programming style.\n *\n * (2)\n * Call the method for a \"root\" element once. Do not call it for each descendants.\n * If the descendants elemenets of a group has itself hover style different from the\n * root group, we can simply mount the style on `el.hoverStyle` for them, but should\n * not call this method for them.\n *\n * @param {module:zrender/Element} el\n * @param {Object|boolean} [hoverStyle] See `graphic.setElementHoverStyle`.\n * @param {Object} [opt]\n * @param {boolean} [opt.hoverSilentOnTouch=false] See `graphic.setAsHoverStyleTrigger`.\n */\n\n\nfunction setHoverStyle(el, hoverStyle, opt) {\n  el.isGroup ? el.traverse(function (child) {\n    // If element has sepcified hoverStyle, then use it instead of given hoverStyle\n    // Often used when item group has a label element and it's hoverStyle is different\n    !child.isGroup && setElementHoverStyle(child, child.hoverStyle || hoverStyle);\n  }) : setElementHoverStyle(el, el.hoverStyle || hoverStyle);\n  setAsHoverStyleTrigger(el, opt);\n}\n/**\n * @param {Object|boolean} [opt] If `false`, means disable trigger.\n * @param {boolean} [opt.hoverSilentOnTouch=false]\n *        In touch device, mouseover event will be trigger on touchstart event\n *        (see module:zrender/dom/HandlerProxy). By this mechanism, we can\n *        conveniently use hoverStyle when tap on touch screen without additional\n *        code for compatibility.\n *        But if the chart/component has select feature, which usually also use\n *        hoverStyle, there might be conflict between 'select-highlight' and\n *        'hover-highlight' especially when roam is enabled (see geo for example).\n *        In this case, hoverSilentOnTouch should be used to disable hover-highlight\n *        on touch device.\n */\n\n\nfunction setAsHoverStyleTrigger(el, opt) {\n  var disable = opt === false;\n  el.__hoverSilentOnTouch = opt != null && opt.hoverSilentOnTouch; // Simple optimize, since this method might be\n  // called for each elements of a group in some cases.\n\n  if (!disable || el.__hoverStyleTrigger) {\n    var method = disable ? 'off' : 'on'; // Duplicated function will be auto-ignored, see Eventful.js.\n\n    el[method]('mouseover', onElementMouseOver)[method]('mouseout', onElementMouseOut); // Emphasis, normal can be triggered manually\n\n    el[method]('emphasis', enterEmphasis)[method]('normal', leaveEmphasis);\n    el.__hoverStyleTrigger = !disable;\n  }\n}\n/**\n * See more info in `setTextStyleCommon`.\n * @param {Object|module:zrender/graphic/Style} normalStyle\n * @param {Object} emphasisStyle\n * @param {module:echarts/model/Model} normalModel\n * @param {module:echarts/model/Model} emphasisModel\n * @param {Object} opt Check `opt` of `setTextStyleCommon` to find other props.\n * @param {string|Function} [opt.defaultText]\n * @param {module:echarts/model/Model} [opt.labelFetcher] Fetch text by\n *      `opt.labelFetcher.getFormattedLabel(opt.labelDataIndex, 'normal'/'emphasis', null, opt.labelDimIndex)`\n * @param {module:echarts/model/Model} [opt.labelDataIndex] Fetch text by\n *      `opt.textFetcher.getFormattedLabel(opt.labelDataIndex, 'normal'/'emphasis', null, opt.labelDimIndex)`\n * @param {module:echarts/model/Model} [opt.labelDimIndex] Fetch text by\n *      `opt.textFetcher.getFormattedLabel(opt.labelDataIndex, 'normal'/'emphasis', null, opt.labelDimIndex)`\n * @param {Object} [normalSpecified]\n * @param {Object} [emphasisSpecified]\n */\n\n\nfunction setLabelStyle(normalStyle, emphasisStyle, normalModel, emphasisModel, opt, normalSpecified, emphasisSpecified) {\n  opt = opt || EMPTY_OBJ;\n  var labelFetcher = opt.labelFetcher;\n  var labelDataIndex = opt.labelDataIndex;\n  var labelDimIndex = opt.labelDimIndex; // This scenario, `label.normal.show = true; label.emphasis.show = false`,\n  // is not supported util someone requests.\n\n  var showNormal = normalModel.getShallow('show');\n  var showEmphasis = emphasisModel.getShallow('show'); // Consider performance, only fetch label when necessary.\n  // If `normal.show` is `false` and `emphasis.show` is `true` and `emphasis.formatter` is not set,\n  // label should be displayed, where text is fetched by `normal.formatter` or `opt.defaultText`.\n\n  var baseText;\n\n  if (showNormal || showEmphasis) {\n    if (labelFetcher) {\n      baseText = labelFetcher.getFormattedLabel(labelDataIndex, 'normal', null, labelDimIndex);\n    }\n\n    if (baseText == null) {\n      baseText = zrUtil.isFunction(opt.defaultText) ? opt.defaultText(labelDataIndex, opt) : opt.defaultText;\n    }\n  }\n\n  var normalStyleText = showNormal ? baseText : null;\n  var emphasisStyleText = showEmphasis ? zrUtil.retrieve2(labelFetcher ? labelFetcher.getFormattedLabel(labelDataIndex, 'emphasis', null, labelDimIndex) : null, baseText) : null; // Optimize: If style.text is null, text will not be drawn.\n\n  if (normalStyleText != null || emphasisStyleText != null) {\n    // Always set `textStyle` even if `normalStyle.text` is null, because default\n    // values have to be set on `normalStyle`.\n    // If we set default values on `emphasisStyle`, consider case:\n    // Firstly, `setOption(... label: {normal: {text: null}, emphasis: {show: true}} ...);`\n    // Secondly, `setOption(... label: {noraml: {show: true, text: 'abc', color: 'red'} ...);`\n    // Then the 'red' will not work on emphasis.\n    setTextStyle(normalStyle, normalModel, normalSpecified, opt);\n    setTextStyle(emphasisStyle, emphasisModel, emphasisSpecified, opt, true);\n  }\n\n  normalStyle.text = normalStyleText;\n  emphasisStyle.text = emphasisStyleText;\n}\n/**\n * Set basic textStyle properties.\n * See more info in `setTextStyleCommon`.\n * @param {Object|module:zrender/graphic/Style} textStyle\n * @param {module:echarts/model/Model} model\n * @param {Object} [specifiedTextStyle] Can be overrided by settings in model.\n * @param {Object} [opt] See `opt` of `setTextStyleCommon`.\n * @param {boolean} [isEmphasis]\n */\n\n\nfunction setTextStyle(textStyle, textStyleModel, specifiedTextStyle, opt, isEmphasis) {\n  setTextStyleCommon(textStyle, textStyleModel, opt, isEmphasis);\n  specifiedTextStyle && zrUtil.extend(textStyle, specifiedTextStyle); // textStyle.host && textStyle.host.dirty && textStyle.host.dirty(false);\n\n  return textStyle;\n}\n/**\n * Set text option in the style.\n * See more info in `setTextStyleCommon`.\n * @deprecated\n * @param {Object} textStyle\n * @param {module:echarts/model/Model} labelModel\n * @param {string|boolean} defaultColor Default text color.\n *        If set as false, it will be processed as a emphasis style.\n */\n\n\nfunction setText(textStyle, labelModel, defaultColor) {\n  var opt = {\n    isRectText: true\n  };\n  var isEmphasis;\n\n  if (defaultColor === false) {\n    isEmphasis = true;\n  } else {\n    // Support setting color as 'auto' to get visual color.\n    opt.autoColor = defaultColor;\n  }\n\n  setTextStyleCommon(textStyle, labelModel, opt, isEmphasis); // textStyle.host && textStyle.host.dirty && textStyle.host.dirty(false);\n}\n/**\n * The uniform entry of set text style, that is, retrieve style definitions\n * from `model` and set to `textStyle` object.\n *\n * Never in merge mode, but in overwrite mode, that is, all of the text style\n * properties will be set. (Consider the states of normal and emphasis and\n * default value can be adopted, merge would make the logic too complicated\n * to manage.)\n *\n * The `textStyle` object can either be a plain object or an instance of\n * `zrender/src/graphic/Style`, and either be the style of normal or emphasis.\n * After this mothod called, the `textStyle` object can then be used in\n * `el.setStyle(textStyle)` or `el.hoverStyle = textStyle`.\n *\n * Default value will be adopted and `insideRollbackOpt` will be created.\n * See `applyDefaultTextStyle` `rollbackDefaultTextStyle` for more details.\n *\n * opt: {\n *      disableBox: boolean, Whether diable drawing box of block (outer most).\n *      isRectText: boolean,\n *      autoColor: string, specify a color when color is 'auto',\n *              for textFill, textStroke, textBackgroundColor, and textBorderColor.\n *              If autoColor specified, it is used as default textFill.\n *      useInsideStyle:\n *              `true`: Use inside style (textFill, textStroke, textStrokeWidth)\n *                  if `textFill` is not specified.\n *              `false`: Do not use inside style.\n *              `null/undefined`: use inside style if `isRectText` is true and\n *                  `textFill` is not specified and textPosition contains `'inside'`.\n *      forceRich: boolean\n * }\n */\n\n\nfunction setTextStyleCommon(textStyle, textStyleModel, opt, isEmphasis) {\n  // Consider there will be abnormal when merge hover style to normal style if given default value.\n  opt = opt || EMPTY_OBJ;\n\n  if (opt.isRectText) {\n    var textPosition = textStyleModel.getShallow('position') || (isEmphasis ? null : 'inside'); // 'outside' is not a valid zr textPostion value, but used\n    // in bar series, and magric type should be considered.\n\n    textPosition === 'outside' && (textPosition = 'top');\n    textStyle.textPosition = textPosition;\n    textStyle.textOffset = textStyleModel.getShallow('offset');\n    var labelRotate = textStyleModel.getShallow('rotate');\n    labelRotate != null && (labelRotate *= Math.PI / 180);\n    textStyle.textRotation = labelRotate;\n    textStyle.textDistance = zrUtil.retrieve2(textStyleModel.getShallow('distance'), isEmphasis ? null : 5);\n  }\n\n  var ecModel = textStyleModel.ecModel;\n  var globalTextStyle = ecModel && ecModel.option.textStyle; // Consider case:\n  // {\n  //     data: [{\n  //         value: 12,\n  //         label: {\n  //             rich: {\n  //                 // no 'a' here but using parent 'a'.\n  //             }\n  //         }\n  //     }],\n  //     rich: {\n  //         a: { ... }\n  //     }\n  // }\n\n  var richItemNames = getRichItemNames(textStyleModel);\n  var richResult;\n\n  if (richItemNames) {\n    richResult = {};\n\n    for (var name in richItemNames) {\n      if (richItemNames.hasOwnProperty(name)) {\n        // Cascade is supported in rich.\n        var richTextStyle = textStyleModel.getModel(['rich', name]); // In rich, never `disableBox`.\n\n        setTokenTextStyle(richResult[name] = {}, richTextStyle, globalTextStyle, opt, isEmphasis);\n      }\n    }\n  }\n\n  textStyle.rich = richResult;\n  setTokenTextStyle(textStyle, textStyleModel, globalTextStyle, opt, isEmphasis, true);\n\n  if (opt.forceRich && !opt.textStyle) {\n    opt.textStyle = {};\n  }\n\n  return textStyle;\n} // Consider case:\n// {\n//     data: [{\n//         value: 12,\n//         label: {\n//             rich: {\n//                 // no 'a' here but using parent 'a'.\n//             }\n//         }\n//     }],\n//     rich: {\n//         a: { ... }\n//     }\n// }\n\n\nfunction getRichItemNames(textStyleModel) {\n  // Use object to remove duplicated names.\n  var richItemNameMap;\n\n  while (textStyleModel && textStyleModel !== textStyleModel.ecModel) {\n    var rich = (textStyleModel.option || EMPTY_OBJ).rich;\n\n    if (rich) {\n      richItemNameMap = richItemNameMap || {};\n\n      for (var name in rich) {\n        if (rich.hasOwnProperty(name)) {\n          richItemNameMap[name] = 1;\n        }\n      }\n    }\n\n    textStyleModel = textStyleModel.parentModel;\n  }\n\n  return richItemNameMap;\n}\n\nfunction setTokenTextStyle(textStyle, textStyleModel, globalTextStyle, opt, isEmphasis, isBlock) {\n  // In merge mode, default value should not be given.\n  globalTextStyle = !isEmphasis && globalTextStyle || EMPTY_OBJ;\n  textStyle.textFill = getAutoColor(textStyleModel.getShallow('color'), opt) || globalTextStyle.color;\n  textStyle.textStroke = getAutoColor(textStyleModel.getShallow('textBorderColor'), opt) || globalTextStyle.textBorderColor;\n  textStyle.textStrokeWidth = zrUtil.retrieve2(textStyleModel.getShallow('textBorderWidth'), globalTextStyle.textBorderWidth); // Save original textPosition, because style.textPosition will be repalced by\n  // real location (like [10, 30]) in zrender.\n\n  textStyle.insideRawTextPosition = textStyle.textPosition;\n\n  if (!isEmphasis) {\n    if (isBlock) {\n      textStyle.insideRollbackOpt = opt;\n      applyDefaultTextStyle(textStyle);\n    } // Set default finally.\n\n\n    if (textStyle.textFill == null) {\n      textStyle.textFill = opt.autoColor;\n    }\n  } // Do not use `getFont` here, because merge should be supported, where\n  // part of these properties may be changed in emphasis style, and the\n  // others should remain their original value got from normal style.\n\n\n  textStyle.fontStyle = textStyleModel.getShallow('fontStyle') || globalTextStyle.fontStyle;\n  textStyle.fontWeight = textStyleModel.getShallow('fontWeight') || globalTextStyle.fontWeight;\n  textStyle.fontSize = textStyleModel.getShallow('fontSize') || globalTextStyle.fontSize;\n  textStyle.fontFamily = textStyleModel.getShallow('fontFamily') || globalTextStyle.fontFamily;\n  textStyle.textAlign = textStyleModel.getShallow('align');\n  textStyle.textVerticalAlign = textStyleModel.getShallow('verticalAlign') || textStyleModel.getShallow('baseline');\n  textStyle.textLineHeight = textStyleModel.getShallow('lineHeight');\n  textStyle.textWidth = textStyleModel.getShallow('width');\n  textStyle.textHeight = textStyleModel.getShallow('height');\n  textStyle.textTag = textStyleModel.getShallow('tag');\n\n  if (!isBlock || !opt.disableBox) {\n    textStyle.textBackgroundColor = getAutoColor(textStyleModel.getShallow('backgroundColor'), opt);\n    textStyle.textPadding = textStyleModel.getShallow('padding');\n    textStyle.textBorderColor = getAutoColor(textStyleModel.getShallow('borderColor'), opt);\n    textStyle.textBorderWidth = textStyleModel.getShallow('borderWidth');\n    textStyle.textBorderRadius = textStyleModel.getShallow('borderRadius');\n    textStyle.textBoxShadowColor = textStyleModel.getShallow('shadowColor');\n    textStyle.textBoxShadowBlur = textStyleModel.getShallow('shadowBlur');\n    textStyle.textBoxShadowOffsetX = textStyleModel.getShallow('shadowOffsetX');\n    textStyle.textBoxShadowOffsetY = textStyleModel.getShallow('shadowOffsetY');\n  }\n\n  textStyle.textShadowColor = textStyleModel.getShallow('textShadowColor') || globalTextStyle.textShadowColor;\n  textStyle.textShadowBlur = textStyleModel.getShallow('textShadowBlur') || globalTextStyle.textShadowBlur;\n  textStyle.textShadowOffsetX = textStyleModel.getShallow('textShadowOffsetX') || globalTextStyle.textShadowOffsetX;\n  textStyle.textShadowOffsetY = textStyleModel.getShallow('textShadowOffsetY') || globalTextStyle.textShadowOffsetY;\n}\n\nfunction getAutoColor(color, opt) {\n  return color !== 'auto' ? color : opt && opt.autoColor ? opt.autoColor : null;\n}\n/**\n * Give some default value to the input `textStyle` object, based on the current settings\n * in this `textStyle` object.\n *\n * The Scenario:\n * when text position is `inside` and `textFill` is not specified, we show\n * text border by default for better view. But it should be considered that text position\n * might be changed when hovering or being emphasis, where the `insideRollback` is used to\n * restore the style.\n *\n * Usage (& NOTICE):\n * When a style object (eithor plain object or instance of `zrender/src/graphic/Style`) is\n * about to be modified on its text related properties, `rollbackDefaultTextStyle` should\n * be called before the modification and `applyDefaultTextStyle` should be called after that.\n * (For the case that all of the text related properties is reset, like `setTextStyleCommon`\n * does, `rollbackDefaultTextStyle` is not needed to be called).\n */\n\n\nfunction applyDefaultTextStyle(textStyle) {\n  var opt = textStyle.insideRollbackOpt; // Only `insideRollbackOpt` created (in `setTextStyleCommon`),\n  // applyDefaultTextStyle works.\n\n  if (!opt || textStyle.textFill != null) {\n    return;\n  }\n\n  var useInsideStyle = opt.useInsideStyle;\n  var textPosition = textStyle.insideRawTextPosition;\n  var insideRollback;\n  var autoColor = opt.autoColor;\n\n  if (useInsideStyle !== false && (useInsideStyle === true || opt.isRectText && textPosition // textPosition can be [10, 30]\n  && typeof textPosition === 'string' && textPosition.indexOf('inside') >= 0)) {\n    insideRollback = {\n      textFill: null,\n      textStroke: textStyle.textStroke,\n      textStrokeWidth: textStyle.textStrokeWidth\n    };\n    textStyle.textFill = '#fff'; // Consider text with #fff overflow its container.\n\n    if (textStyle.textStroke == null) {\n      textStyle.textStroke = autoColor;\n      textStyle.textStrokeWidth == null && (textStyle.textStrokeWidth = 2);\n    }\n  } else if (autoColor != null) {\n    insideRollback = {\n      textFill: null\n    };\n    textStyle.textFill = autoColor;\n  } // Always set `insideRollback`, for clearing previous.\n\n\n  if (insideRollback) {\n    textStyle.insideRollback = insideRollback;\n  }\n}\n/**\n * Consider the case: in a scatter,\n * label: {\n *     normal: {position: 'inside'},\n *     emphasis: {position: 'top'}\n * }\n * In the normal state, the `textFill` will be set as '#fff' for pretty view (see\n * `applyDefaultTextStyle`), but when switching to emphasis state, the `textFill`\n * should be retured to 'autoColor', but not keep '#fff'.\n */\n\n\nfunction rollbackDefaultTextStyle(style) {\n  var insideRollback = style.insideRollback;\n\n  if (insideRollback) {\n    style.textFill = insideRollback.textFill;\n    style.textStroke = insideRollback.textStroke;\n    style.textStrokeWidth = insideRollback.textStrokeWidth;\n    style.insideRollback = null;\n  }\n}\n\nfunction getFont(opt, ecModel) {\n  // ecModel or default text style model.\n  var gTextStyleModel = ecModel || ecModel.getModel('textStyle');\n  return zrUtil.trim([// FIXME in node-canvas fontWeight is before fontStyle\n  opt.fontStyle || gTextStyleModel && gTextStyleModel.getShallow('fontStyle') || '', opt.fontWeight || gTextStyleModel && gTextStyleModel.getShallow('fontWeight') || '', (opt.fontSize || gTextStyleModel && gTextStyleModel.getShallow('fontSize') || 12) + 'px', opt.fontFamily || gTextStyleModel && gTextStyleModel.getShallow('fontFamily') || 'sans-serif'].join(' '));\n}\n\nfunction animateOrSetProps(isUpdate, el, props, animatableModel, dataIndex, cb) {\n  if (typeof dataIndex === 'function') {\n    cb = dataIndex;\n    dataIndex = null;\n  } // Do not check 'animation' property directly here. Consider this case:\n  // animation model is an `itemModel`, whose does not have `isAnimationEnabled`\n  // but its parent model (`seriesModel`) does.\n\n\n  var animationEnabled = animatableModel && animatableModel.isAnimationEnabled();\n\n  if (animationEnabled) {\n    var postfix = isUpdate ? 'Update' : '';\n    var duration = animatableModel.getShallow('animationDuration' + postfix);\n    var animationEasing = animatableModel.getShallow('animationEasing' + postfix);\n    var animationDelay = animatableModel.getShallow('animationDelay' + postfix);\n\n    if (typeof animationDelay === 'function') {\n      animationDelay = animationDelay(dataIndex, animatableModel.getAnimationDelayParams ? animatableModel.getAnimationDelayParams(el, dataIndex) : null);\n    }\n\n    if (typeof duration === 'function') {\n      duration = duration(dataIndex);\n    }\n\n    duration > 0 ? el.animateTo(props, duration, animationDelay || 0, animationEasing, cb, !!cb) : (el.stopAnimation(), el.attr(props), cb && cb());\n  } else {\n    el.stopAnimation();\n    el.attr(props);\n    cb && cb();\n  }\n}\n/**\n * Update graphic element properties with or without animation according to the\n * configuration in series.\n *\n * Caution: this method will stop previous animation.\n * So if do not use this method to one element twice before\n * animation starts, unless you know what you are doing.\n *\n * @param {module:zrender/Element} el\n * @param {Object} props\n * @param {module:echarts/model/Model} [animatableModel]\n * @param {number} [dataIndex]\n * @param {Function} [cb]\n * @example\n *     graphic.updateProps(el, {\n *         position: [100, 100]\n *     }, seriesModel, dataIndex, function () { console.log('Animation done!'); });\n *     // Or\n *     graphic.updateProps(el, {\n *         position: [100, 100]\n *     }, seriesModel, function () { console.log('Animation done!'); });\n */\n\n\nfunction updateProps(el, props, animatableModel, dataIndex, cb) {\n  animateOrSetProps(true, el, props, animatableModel, dataIndex, cb);\n}\n/**\n * Init graphic element properties with or without animation according to the\n * configuration in series.\n *\n * Caution: this method will stop previous animation.\n * So if do not use this method to one element twice before\n * animation starts, unless you know what you are doing.\n *\n * @param {module:zrender/Element} el\n * @param {Object} props\n * @param {module:echarts/model/Model} [animatableModel]\n * @param {number} [dataIndex]\n * @param {Function} cb\n */\n\n\nfunction initProps(el, props, animatableModel, dataIndex, cb) {\n  animateOrSetProps(false, el, props, animatableModel, dataIndex, cb);\n}\n/**\n * Get transform matrix of target (param target),\n * in coordinate of its ancestor (param ancestor)\n *\n * @param {module:zrender/mixin/Transformable} target\n * @param {module:zrender/mixin/Transformable} [ancestor]\n */\n\n\nfunction getTransform(target, ancestor) {\n  var mat = matrix.identity([]);\n\n  while (target && target !== ancestor) {\n    matrix.mul(mat, target.getLocalTransform(), mat);\n    target = target.parent;\n  }\n\n  return mat;\n}\n/**\n * Apply transform to an vertex.\n * @param {Array.<number>} target [x, y]\n * @param {Array.<number>|TypedArray.<number>|Object} transform Can be:\n *      + Transform matrix: like [1, 0, 0, 1, 0, 0]\n *      + {position, rotation, scale}, the same as `zrender/Transformable`.\n * @param {boolean=} invert Whether use invert matrix.\n * @return {Array.<number>} [x, y]\n */\n\n\nfunction applyTransform(target, transform, invert) {\n  if (transform && !zrUtil.isArrayLike(transform)) {\n    transform = Transformable.getLocalTransform(transform);\n  }\n\n  if (invert) {\n    transform = matrix.invert([], transform);\n  }\n\n  return vector.applyTransform([], target, transform);\n}\n/**\n * @param {string} direction 'left' 'right' 'top' 'bottom'\n * @param {Array.<number>} transform Transform matrix: like [1, 0, 0, 1, 0, 0]\n * @param {boolean=} invert Whether use invert matrix.\n * @return {string} Transformed direction. 'left' 'right' 'top' 'bottom'\n */\n\n\nfunction transformDirection(direction, transform, invert) {\n  // Pick a base, ensure that transform result will not be (0, 0).\n  var hBase = transform[4] === 0 || transform[5] === 0 || transform[0] === 0 ? 1 : Math.abs(2 * transform[4] / transform[0]);\n  var vBase = transform[4] === 0 || transform[5] === 0 || transform[2] === 0 ? 1 : Math.abs(2 * transform[4] / transform[2]);\n  var vertex = [direction === 'left' ? -hBase : direction === 'right' ? hBase : 0, direction === 'top' ? -vBase : direction === 'bottom' ? vBase : 0];\n  vertex = applyTransform(vertex, transform, invert);\n  return Math.abs(vertex[0]) > Math.abs(vertex[1]) ? vertex[0] > 0 ? 'right' : 'left' : vertex[1] > 0 ? 'bottom' : 'top';\n}\n/**\n * Apply group transition animation from g1 to g2.\n * If no animatableModel, no animation.\n */\n\n\nfunction groupTransition(g1, g2, animatableModel, cb) {\n  if (!g1 || !g2) {\n    return;\n  }\n\n  function getElMap(g) {\n    var elMap = {};\n    g.traverse(function (el) {\n      if (!el.isGroup && el.anid) {\n        elMap[el.anid] = el;\n      }\n    });\n    return elMap;\n  }\n\n  function getAnimatableProps(el) {\n    var obj = {\n      position: vector.clone(el.position),\n      rotation: el.rotation\n    };\n\n    if (el.shape) {\n      obj.shape = zrUtil.extend({}, el.shape);\n    }\n\n    return obj;\n  }\n\n  var elMap1 = getElMap(g1);\n  g2.traverse(function (el) {\n    if (!el.isGroup && el.anid) {\n      var oldEl = elMap1[el.anid];\n\n      if (oldEl) {\n        var newProp = getAnimatableProps(el);\n        el.attr(getAnimatableProps(oldEl));\n        updateProps(el, newProp, animatableModel, el.dataIndex);\n      } // else {\n      //     if (el.previousProps) {\n      //         graphic.updateProps\n      //     }\n      // }\n\n    }\n  });\n}\n/**\n * @param {Array.<Array.<number>>} points Like: [[23, 44], [53, 66], ...]\n * @param {Object} rect {x, y, width, height}\n * @return {Array.<Array.<number>>} A new clipped points.\n */\n\n\nfunction clipPointsByRect(points, rect) {\n  // FIXME: this way migth be incorrect when grpahic clipped by a corner.\n  // and when element have border.\n  return zrUtil.map(points, function (point) {\n    var x = point[0];\n    x = mathMax(x, rect.x);\n    x = mathMin(x, rect.x + rect.width);\n    var y = point[1];\n    y = mathMax(y, rect.y);\n    y = mathMin(y, rect.y + rect.height);\n    return [x, y];\n  });\n}\n/**\n * @param {Object} targetRect {x, y, width, height}\n * @param {Object} rect {x, y, width, height}\n * @return {Object} A new clipped rect. If rect size are negative, return undefined.\n */\n\n\nfunction clipRectByRect(targetRect, rect) {\n  var x = mathMax(targetRect.x, rect.x);\n  var x2 = mathMin(targetRect.x + targetRect.width, rect.x + rect.width);\n  var y = mathMax(targetRect.y, rect.y);\n  var y2 = mathMin(targetRect.y + targetRect.height, rect.y + rect.height); // If the total rect is cliped, nothing, including the border,\n  // should be painted. So return undefined.\n\n  if (x2 >= x && y2 >= y) {\n    return {\n      x: x,\n      y: y,\n      width: x2 - x,\n      height: y2 - y\n    };\n  }\n}\n/**\n * @param {string} iconStr Support 'image://' or 'path://' or direct svg path.\n * @param {Object} [opt] Properties of `module:zrender/Element`, except `style`.\n * @param {Object} [rect] {x, y, width, height}\n * @return {module:zrender/Element} Icon path or image element.\n */\n\n\nfunction createIcon(iconStr, opt, rect) {\n  opt = zrUtil.extend({\n    rectHover: true\n  }, opt);\n  var style = opt.style = {\n    strokeNoScale: true\n  };\n  rect = rect || {\n    x: -1,\n    y: -1,\n    width: 2,\n    height: 2\n  };\n\n  if (iconStr) {\n    return iconStr.indexOf('image://') === 0 ? (style.image = iconStr.slice(8), zrUtil.defaults(style, rect), new ZImage(opt)) : makePath(iconStr.replace('path://', ''), opt, rect, 'center');\n  }\n}\n\nexports.Z2_EMPHASIS_LIFT = Z2_EMPHASIS_LIFT;\nexports.extendShape = extendShape;\nexports.extendPath = extendPath;\nexports.makePath = makePath;\nexports.makeImage = makeImage;\nexports.mergePath = mergePath;\nexports.resizePath = resizePath;\nexports.subPixelOptimizeLine = subPixelOptimizeLine;\nexports.subPixelOptimizeRect = subPixelOptimizeRect;\nexports.subPixelOptimize = subPixelOptimize;\nexports.setElementHoverStyle = setElementHoverStyle;\nexports.isInEmphasis = isInEmphasis;\nexports.setHoverStyle = setHoverStyle;\nexports.setAsHoverStyleTrigger = setAsHoverStyleTrigger;\nexports.setLabelStyle = setLabelStyle;\nexports.setTextStyle = setTextStyle;\nexports.setText = setText;\nexports.getFont = getFont;\nexports.updateProps = updateProps;\nexports.initProps = initProps;\nexports.getTransform = getTransform;\nexports.applyTransform = applyTransform;\nexports.transformDirection = transformDirection;\nexports.groupTransition = groupTransition;\nexports.clipPointsByRect = clipPointsByRect;\nexports.clipRectByRect = clipRectByRect;\nexports.createIcon = createIcon;","var Path = require(\"../graphic/Path\");\n\nvar PathProxy = require(\"../core/PathProxy\");\n\nvar transformPath = require(\"./transformPath\");\n\n// command chars\n// var cc = [\n//     'm', 'M', 'l', 'L', 'v', 'V', 'h', 'H', 'z', 'Z',\n//     'c', 'C', 'q', 'Q', 't', 'T', 's', 'S', 'a', 'A'\n// ];\nvar mathSqrt = Math.sqrt;\nvar mathSin = Math.sin;\nvar mathCos = Math.cos;\nvar PI = Math.PI;\n\nvar vMag = function (v) {\n  return Math.sqrt(v[0] * v[0] + v[1] * v[1]);\n};\n\nvar vRatio = function (u, v) {\n  return (u[0] * v[0] + u[1] * v[1]) / (vMag(u) * vMag(v));\n};\n\nvar vAngle = function (u, v) {\n  return (u[0] * v[1] < u[1] * v[0] ? -1 : 1) * Math.acos(vRatio(u, v));\n};\n\nfunction processArc(x1, y1, x2, y2, fa, fs, rx, ry, psiDeg, cmd, path) {\n  var psi = psiDeg * (PI / 180.0);\n  var xp = mathCos(psi) * (x1 - x2) / 2.0 + mathSin(psi) * (y1 - y2) / 2.0;\n  var yp = -1 * mathSin(psi) * (x1 - x2) / 2.0 + mathCos(psi) * (y1 - y2) / 2.0;\n  var lambda = xp * xp / (rx * rx) + yp * yp / (ry * ry);\n\n  if (lambda > 1) {\n    rx *= mathSqrt(lambda);\n    ry *= mathSqrt(lambda);\n  }\n\n  var f = (fa === fs ? -1 : 1) * mathSqrt((rx * rx * (ry * ry) - rx * rx * (yp * yp) - ry * ry * (xp * xp)) / (rx * rx * (yp * yp) + ry * ry * (xp * xp))) || 0;\n  var cxp = f * rx * yp / ry;\n  var cyp = f * -ry * xp / rx;\n  var cx = (x1 + x2) / 2.0 + mathCos(psi) * cxp - mathSin(psi) * cyp;\n  var cy = (y1 + y2) / 2.0 + mathSin(psi) * cxp + mathCos(psi) * cyp;\n  var theta = vAngle([1, 0], [(xp - cxp) / rx, (yp - cyp) / ry]);\n  var u = [(xp - cxp) / rx, (yp - cyp) / ry];\n  var v = [(-1 * xp - cxp) / rx, (-1 * yp - cyp) / ry];\n  var dTheta = vAngle(u, v);\n\n  if (vRatio(u, v) <= -1) {\n    dTheta = PI;\n  }\n\n  if (vRatio(u, v) >= 1) {\n    dTheta = 0;\n  }\n\n  if (fs === 0 && dTheta > 0) {\n    dTheta = dTheta - 2 * PI;\n  }\n\n  if (fs === 1 && dTheta < 0) {\n    dTheta = dTheta + 2 * PI;\n  }\n\n  path.addData(cmd, cx, cy, rx, ry, theta, dTheta, psi, fs);\n}\n\nvar commandReg = /([mlvhzcqtsa])([^mlvhzcqtsa]*)/ig; // Consider case:\n// (1) delimiter can be comma or space, where continuous commas\n// or spaces should be seen as one comma.\n// (2) value can be like:\n// '2e-4', 'l.5.9' (ignore 0), 'M-10-10', 'l-2.43e-1,34.9983',\n// 'l-.5E1,54', '121-23-44-11' (no delimiter)\n\nvar numberReg = /-?([0-9]*\\.)?[0-9]+([eE]-?[0-9]+)?/g; // var valueSplitReg = /[\\s,]+/;\n\nfunction createPathProxyFromString(data) {\n  if (!data) {\n    return new PathProxy();\n  } // var data = data.replace(/-/g, ' -')\n  //     .replace(/  /g, ' ')\n  //     .replace(/ /g, ',')\n  //     .replace(/,,/g, ',');\n  // var n;\n  // create pipes so that we can split the data\n  // for (n = 0; n < cc.length; n++) {\n  //     cs = cs.replace(new RegExp(cc[n], 'g'), '|' + cc[n]);\n  // }\n  // data = data.replace(/-/g, ',-');\n  // create array\n  // var arr = cs.split('|');\n  // init context point\n\n\n  var cpx = 0;\n  var cpy = 0;\n  var subpathX = cpx;\n  var subpathY = cpy;\n  var prevCmd;\n  var path = new PathProxy();\n  var CMD = PathProxy.CMD; // commandReg.lastIndex = 0;\n  // var cmdResult;\n  // while ((cmdResult = commandReg.exec(data)) != null) {\n  //     var cmdStr = cmdResult[1];\n  //     var cmdContent = cmdResult[2];\n\n  var cmdList = data.match(commandReg);\n\n  for (var l = 0; l < cmdList.length; l++) {\n    var cmdText = cmdList[l];\n    var cmdStr = cmdText.charAt(0);\n    var cmd; // String#split is faster a little bit than String#replace or RegExp#exec.\n    // var p = cmdContent.split(valueSplitReg);\n    // var pLen = 0;\n    // for (var i = 0; i < p.length; i++) {\n    //     // '' and other invalid str => NaN\n    //     var val = parseFloat(p[i]);\n    //     !isNaN(val) && (p[pLen++] = val);\n    // }\n\n    var p = cmdText.match(numberReg) || [];\n    var pLen = p.length;\n\n    for (var i = 0; i < pLen; i++) {\n      p[i] = parseFloat(p[i]);\n    }\n\n    var off = 0;\n\n    while (off < pLen) {\n      var ctlPtx;\n      var ctlPty;\n      var rx;\n      var ry;\n      var psi;\n      var fa;\n      var fs;\n      var x1 = cpx;\n      var y1 = cpy; // convert l, H, h, V, and v to L\n\n      switch (cmdStr) {\n        case 'l':\n          cpx += p[off++];\n          cpy += p[off++];\n          cmd = CMD.L;\n          path.addData(cmd, cpx, cpy);\n          break;\n\n        case 'L':\n          cpx = p[off++];\n          cpy = p[off++];\n          cmd = CMD.L;\n          path.addData(cmd, cpx, cpy);\n          break;\n\n        case 'm':\n          cpx += p[off++];\n          cpy += p[off++];\n          cmd = CMD.M;\n          path.addData(cmd, cpx, cpy);\n          subpathX = cpx;\n          subpathY = cpy;\n          cmdStr = 'l';\n          break;\n\n        case 'M':\n          cpx = p[off++];\n          cpy = p[off++];\n          cmd = CMD.M;\n          path.addData(cmd, cpx, cpy);\n          subpathX = cpx;\n          subpathY = cpy;\n          cmdStr = 'L';\n          break;\n\n        case 'h':\n          cpx += p[off++];\n          cmd = CMD.L;\n          path.addData(cmd, cpx, cpy);\n          break;\n\n        case 'H':\n          cpx = p[off++];\n          cmd = CMD.L;\n          path.addData(cmd, cpx, cpy);\n          break;\n\n        case 'v':\n          cpy += p[off++];\n          cmd = CMD.L;\n          path.addData(cmd, cpx, cpy);\n          break;\n\n        case 'V':\n          cpy = p[off++];\n          cmd = CMD.L;\n          path.addData(cmd, cpx, cpy);\n          break;\n\n        case 'C':\n          cmd = CMD.C;\n          path.addData(cmd, p[off++], p[off++], p[off++], p[off++], p[off++], p[off++]);\n          cpx = p[off - 2];\n          cpy = p[off - 1];\n          break;\n\n        case 'c':\n          cmd = CMD.C;\n          path.addData(cmd, p[off++] + cpx, p[off++] + cpy, p[off++] + cpx, p[off++] + cpy, p[off++] + cpx, p[off++] + cpy);\n          cpx += p[off - 2];\n          cpy += p[off - 1];\n          break;\n\n        case 'S':\n          ctlPtx = cpx;\n          ctlPty = cpy;\n          var len = path.len();\n          var pathData = path.data;\n\n          if (prevCmd === CMD.C) {\n            ctlPtx += cpx - pathData[len - 4];\n            ctlPty += cpy - pathData[len - 3];\n          }\n\n          cmd = CMD.C;\n          x1 = p[off++];\n          y1 = p[off++];\n          cpx = p[off++];\n          cpy = p[off++];\n          path.addData(cmd, ctlPtx, ctlPty, x1, y1, cpx, cpy);\n          break;\n\n        case 's':\n          ctlPtx = cpx;\n          ctlPty = cpy;\n          var len = path.len();\n          var pathData = path.data;\n\n          if (prevCmd === CMD.C) {\n            ctlPtx += cpx - pathData[len - 4];\n            ctlPty += cpy - pathData[len - 3];\n          }\n\n          cmd = CMD.C;\n          x1 = cpx + p[off++];\n          y1 = cpy + p[off++];\n          cpx += p[off++];\n          cpy += p[off++];\n          path.addData(cmd, ctlPtx, ctlPty, x1, y1, cpx, cpy);\n          break;\n\n        case 'Q':\n          x1 = p[off++];\n          y1 = p[off++];\n          cpx = p[off++];\n          cpy = p[off++];\n          cmd = CMD.Q;\n          path.addData(cmd, x1, y1, cpx, cpy);\n          break;\n\n        case 'q':\n          x1 = p[off++] + cpx;\n          y1 = p[off++] + cpy;\n          cpx += p[off++];\n          cpy += p[off++];\n          cmd = CMD.Q;\n          path.addData(cmd, x1, y1, cpx, cpy);\n          break;\n\n        case 'T':\n          ctlPtx = cpx;\n          ctlPty = cpy;\n          var len = path.len();\n          var pathData = path.data;\n\n          if (prevCmd === CMD.Q) {\n            ctlPtx += cpx - pathData[len - 4];\n            ctlPty += cpy - pathData[len - 3];\n          }\n\n          cpx = p[off++];\n          cpy = p[off++];\n          cmd = CMD.Q;\n          path.addData(cmd, ctlPtx, ctlPty, cpx, cpy);\n          break;\n\n        case 't':\n          ctlPtx = cpx;\n          ctlPty = cpy;\n          var len = path.len();\n          var pathData = path.data;\n\n          if (prevCmd === CMD.Q) {\n            ctlPtx += cpx - pathData[len - 4];\n            ctlPty += cpy - pathData[len - 3];\n          }\n\n          cpx += p[off++];\n          cpy += p[off++];\n          cmd = CMD.Q;\n          path.addData(cmd, ctlPtx, ctlPty, cpx, cpy);\n          break;\n\n        case 'A':\n          rx = p[off++];\n          ry = p[off++];\n          psi = p[off++];\n          fa = p[off++];\n          fs = p[off++];\n          x1 = cpx, y1 = cpy;\n          cpx = p[off++];\n          cpy = p[off++];\n          cmd = CMD.A;\n          processArc(x1, y1, cpx, cpy, fa, fs, rx, ry, psi, cmd, path);\n          break;\n\n        case 'a':\n          rx = p[off++];\n          ry = p[off++];\n          psi = p[off++];\n          fa = p[off++];\n          fs = p[off++];\n          x1 = cpx, y1 = cpy;\n          cpx += p[off++];\n          cpy += p[off++];\n          cmd = CMD.A;\n          processArc(x1, y1, cpx, cpy, fa, fs, rx, ry, psi, cmd, path);\n          break;\n      }\n    }\n\n    if (cmdStr === 'z' || cmdStr === 'Z') {\n      cmd = CMD.Z;\n      path.addData(cmd); // z may be in the middle of the path.\n\n      cpx = subpathX;\n      cpy = subpathY;\n    }\n\n    prevCmd = cmd;\n  }\n\n  path.toStatic();\n  return path;\n} // TODO Optimize double memory cost problem\n\n\nfunction createPathOptions(str, opts) {\n  var pathProxy = createPathProxyFromString(str);\n  opts = opts || {};\n\n  opts.buildPath = function (path) {\n    if (path.setData) {\n      path.setData(pathProxy.data); // Svg and vml renderer don't have context\n\n      var ctx = path.getContext();\n\n      if (ctx) {\n        path.rebuildPath(ctx);\n      }\n    } else {\n      var ctx = path;\n      pathProxy.rebuildPath(ctx);\n    }\n  };\n\n  opts.applyTransform = function (m) {\n    transformPath(pathProxy, m);\n    this.dirty(true);\n  };\n\n  return opts;\n}\n/**\n * Create a Path object from path string data\n * http://www.w3.org/TR/SVG/paths.html#PathData\n * @param  {Object} opts Other options\n */\n\n\nfunction createFromString(str, opts) {\n  return new Path(createPathOptions(str, opts));\n}\n/**\n * Create a Path class from path string data\n * @param  {string} str\n * @param  {Object} opts Other options\n */\n\n\nfunction extendFromString(str, opts) {\n  return Path.extend(createPathOptions(str, opts));\n}\n/**\n * Merge multiple paths\n */\n// TODO Apply transform\n// TODO stroke dash\n// TODO Optimize double memory cost problem\n\n\nfunction mergePath(pathEls, opts) {\n  var pathList = [];\n  var len = pathEls.length;\n\n  for (var i = 0; i < len; i++) {\n    var pathEl = pathEls[i];\n\n    if (!pathEl.path) {\n      pathEl.createPathProxy();\n    }\n\n    if (pathEl.__dirtyPath) {\n      pathEl.buildPath(pathEl.path, pathEl.shape, true);\n    }\n\n    pathList.push(pathEl.path);\n  }\n\n  var pathBundle = new Path(opts); // Need path proxy.\n\n  pathBundle.createPathProxy();\n\n  pathBundle.buildPath = function (path) {\n    path.appendPath(pathList); // Svg and vml renderer don't have context\n\n    var ctx = path.getContext();\n\n    if (ctx) {\n      path.rebuildPath(ctx);\n    }\n  };\n\n  return pathBundle;\n}\n\nexports.createFromString = createFromString;\nexports.extendFromString = extendFromString;\nexports.mergePath = mergePath;","var fixShadow = require(\"./helper/fixShadow\");\n\nvar _constant = require(\"./constant\");\n\nvar ContextCachedBy = _constant.ContextCachedBy;\nvar STYLE_COMMON_PROPS = [['shadowBlur', 0], ['shadowOffsetX', 0], ['shadowOffsetY', 0], ['shadowColor', '#000'], ['lineCap', 'butt'], ['lineJoin', 'miter'], ['miterLimit', 10]]; // var SHADOW_PROPS = STYLE_COMMON_PROPS.slice(0, 4);\n// var LINE_PROPS = STYLE_COMMON_PROPS.slice(4);\n\nvar Style = function (opts) {\n  this.extendFrom(opts, false);\n};\n\nfunction createLinearGradient(ctx, obj, rect) {\n  var x = obj.x == null ? 0 : obj.x;\n  var x2 = obj.x2 == null ? 1 : obj.x2;\n  var y = obj.y == null ? 0 : obj.y;\n  var y2 = obj.y2 == null ? 0 : obj.y2;\n\n  if (!obj.global) {\n    x = x * rect.width + rect.x;\n    x2 = x2 * rect.width + rect.x;\n    y = y * rect.height + rect.y;\n    y2 = y2 * rect.height + rect.y;\n  } // Fix NaN when rect is Infinity\n\n\n  x = isNaN(x) ? 0 : x;\n  x2 = isNaN(x2) ? 1 : x2;\n  y = isNaN(y) ? 0 : y;\n  y2 = isNaN(y2) ? 0 : y2;\n  var canvasGradient = ctx.createLinearGradient(x, y, x2, y2);\n  return canvasGradient;\n}\n\nfunction createRadialGradient(ctx, obj, rect) {\n  var width = rect.width;\n  var height = rect.height;\n  var min = Math.min(width, height);\n  var x = obj.x == null ? 0.5 : obj.x;\n  var y = obj.y == null ? 0.5 : obj.y;\n  var r = obj.r == null ? 0.5 : obj.r;\n\n  if (!obj.global) {\n    x = x * width + rect.x;\n    y = y * height + rect.y;\n    r = r * min;\n  }\n\n  var canvasGradient = ctx.createRadialGradient(x, y, 0, x, y, r);\n  return canvasGradient;\n}\n\nStyle.prototype = {\n  constructor: Style,\n\n  /**\n   * @type {string}\n   */\n  fill: '#000',\n\n  /**\n   * @type {string}\n   */\n  stroke: null,\n\n  /**\n   * @type {number}\n   */\n  opacity: 1,\n\n  /**\n   * @type {number}\n   */\n  fillOpacity: null,\n\n  /**\n   * @type {number}\n   */\n  strokeOpacity: null,\n\n  /**\n   * @type {Array.<number>}\n   */\n  lineDash: null,\n\n  /**\n   * @type {number}\n   */\n  lineDashOffset: 0,\n\n  /**\n   * @type {number}\n   */\n  shadowBlur: 0,\n\n  /**\n   * @type {number}\n   */\n  shadowOffsetX: 0,\n\n  /**\n   * @type {number}\n   */\n  shadowOffsetY: 0,\n\n  /**\n   * @type {number}\n   */\n  lineWidth: 1,\n\n  /**\n   * If stroke ignore scale\n   * @type {Boolean}\n   */\n  strokeNoScale: false,\n  // Bounding rect text configuration\n  // Not affected by element transform\n\n  /**\n   * @type {string}\n   */\n  text: null,\n\n  /**\n   * If `fontSize` or `fontFamily` exists, `font` will be reset by\n   * `fontSize`, `fontStyle`, `fontWeight`, `fontFamily`.\n   * So do not visit it directly in upper application (like echarts),\n   * but use `contain/text#makeFont` instead.\n   * @type {string}\n   */\n  font: null,\n\n  /**\n   * The same as font. Use font please.\n   * @deprecated\n   * @type {string}\n   */\n  textFont: null,\n\n  /**\n   * It helps merging respectively, rather than parsing an entire font string.\n   * @type {string}\n   */\n  fontStyle: null,\n\n  /**\n   * It helps merging respectively, rather than parsing an entire font string.\n   * @type {string}\n   */\n  fontWeight: null,\n\n  /**\n   * It helps merging respectively, rather than parsing an entire font string.\n   * Should be 12 but not '12px'.\n   * @type {number}\n   */\n  fontSize: null,\n\n  /**\n   * It helps merging respectively, rather than parsing an entire font string.\n   * @type {string}\n   */\n  fontFamily: null,\n\n  /**\n   * Reserved for special functinality, like 'hr'.\n   * @type {string}\n   */\n  textTag: null,\n\n  /**\n   * @type {string}\n   */\n  textFill: '#000',\n\n  /**\n   * @type {string}\n   */\n  textStroke: null,\n\n  /**\n   * @type {number}\n   */\n  textWidth: null,\n\n  /**\n   * Only for textBackground.\n   * @type {number}\n   */\n  textHeight: null,\n\n  /**\n   * textStroke may be set as some color as a default\n   * value in upper applicaion, where the default value\n   * of textStrokeWidth should be 0 to make sure that\n   * user can choose to do not use text stroke.\n   * @type {number}\n   */\n  textStrokeWidth: 0,\n\n  /**\n   * @type {number}\n   */\n  textLineHeight: null,\n\n  /**\n   * 'inside', 'left', 'right', 'top', 'bottom'\n   * [x, y]\n   * Based on x, y of rect.\n   * @type {string|Array.<number>}\n   * @default 'inside'\n   */\n  textPosition: 'inside',\n\n  /**\n   * If not specified, use the boundingRect of a `displayable`.\n   * @type {Object}\n   */\n  textRect: null,\n\n  /**\n   * [x, y]\n   * @type {Array.<number>}\n   */\n  textOffset: null,\n\n  /**\n   * @type {string}\n   */\n  textAlign: null,\n\n  /**\n   * @type {string}\n   */\n  textVerticalAlign: null,\n\n  /**\n   * @type {number}\n   */\n  textDistance: 5,\n\n  /**\n   * @type {string}\n   */\n  textShadowColor: 'transparent',\n\n  /**\n   * @type {number}\n   */\n  textShadowBlur: 0,\n\n  /**\n   * @type {number}\n   */\n  textShadowOffsetX: 0,\n\n  /**\n   * @type {number}\n   */\n  textShadowOffsetY: 0,\n\n  /**\n   * @type {string}\n   */\n  textBoxShadowColor: 'transparent',\n\n  /**\n   * @type {number}\n   */\n  textBoxShadowBlur: 0,\n\n  /**\n   * @type {number}\n   */\n  textBoxShadowOffsetX: 0,\n\n  /**\n   * @type {number}\n   */\n  textBoxShadowOffsetY: 0,\n\n  /**\n   * Whether transform text.\n   * Only useful in Path and Image element\n   * @type {boolean}\n   */\n  transformText: false,\n\n  /**\n   * Text rotate around position of Path or Image\n   * Only useful in Path and Image element and transformText is false.\n   */\n  textRotation: 0,\n\n  /**\n   * Text origin of text rotation, like [10, 40].\n   * Based on x, y of rect.\n   * Useful in label rotation of circular symbol.\n   * By default, this origin is textPosition.\n   * Can be 'center'.\n   * @type {string|Array.<number>}\n   */\n  textOrigin: null,\n\n  /**\n   * @type {string}\n   */\n  textBackgroundColor: null,\n\n  /**\n   * @type {string}\n   */\n  textBorderColor: null,\n\n  /**\n   * @type {number}\n   */\n  textBorderWidth: 0,\n\n  /**\n   * @type {number}\n   */\n  textBorderRadius: 0,\n\n  /**\n   * Can be `2` or `[2, 4]` or `[2, 3, 4, 5]`\n   * @type {number|Array.<number>}\n   */\n  textPadding: null,\n\n  /**\n   * Text styles for rich text.\n   * @type {Object}\n   */\n  rich: null,\n\n  /**\n   * {outerWidth, outerHeight, ellipsis, placeholder}\n   * @type {Object}\n   */\n  truncate: null,\n\n  /**\n   * https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/globalCompositeOperation\n   * @type {string}\n   */\n  blend: null,\n\n  /**\n   * @param {CanvasRenderingContext2D} ctx\n   */\n  bind: function (ctx, el, prevEl) {\n    var style = this;\n    var prevStyle = prevEl && prevEl.style; // If no prevStyle, it means first draw.\n    // Only apply cache if the last time cachced by this function.\n\n    var notCheckCache = !prevStyle || ctx.__attrCachedBy !== ContextCachedBy.STYLE_BIND;\n    ctx.__attrCachedBy = ContextCachedBy.STYLE_BIND;\n\n    for (var i = 0; i < STYLE_COMMON_PROPS.length; i++) {\n      var prop = STYLE_COMMON_PROPS[i];\n      var styleName = prop[0];\n\n      if (notCheckCache || style[styleName] !== prevStyle[styleName]) {\n        // FIXME Invalid property value will cause style leak from previous element.\n        ctx[styleName] = fixShadow(ctx, styleName, style[styleName] || prop[1]);\n      }\n    }\n\n    if (notCheckCache || style.fill !== prevStyle.fill) {\n      ctx.fillStyle = style.fill;\n    }\n\n    if (notCheckCache || style.stroke !== prevStyle.stroke) {\n      ctx.strokeStyle = style.stroke;\n    }\n\n    if (notCheckCache || style.opacity !== prevStyle.opacity) {\n      ctx.globalAlpha = style.opacity == null ? 1 : style.opacity;\n    }\n\n    if (notCheckCache || style.blend !== prevStyle.blend) {\n      ctx.globalCompositeOperation = style.blend || 'source-over';\n    }\n\n    if (this.hasStroke()) {\n      var lineWidth = style.lineWidth;\n      ctx.lineWidth = lineWidth / (this.strokeNoScale && el && el.getLineScale ? el.getLineScale() : 1);\n    }\n  },\n  hasFill: function () {\n    var fill = this.fill;\n    return fill != null && fill !== 'none';\n  },\n  hasStroke: function () {\n    var stroke = this.stroke;\n    return stroke != null && stroke !== 'none' && this.lineWidth > 0;\n  },\n\n  /**\n   * Extend from other style\n   * @param {zrender/graphic/Style} otherStyle\n   * @param {boolean} overwrite true: overwrirte any way.\n   *                            false: overwrite only when !target.hasOwnProperty\n   *                            others: overwrite when property is not null/undefined.\n   */\n  extendFrom: function (otherStyle, overwrite) {\n    if (otherStyle) {\n      for (var name in otherStyle) {\n        if (otherStyle.hasOwnProperty(name) && (overwrite === true || (overwrite === false ? !this.hasOwnProperty(name) : otherStyle[name] != null))) {\n          this[name] = otherStyle[name];\n        }\n      }\n    }\n  },\n\n  /**\n   * Batch setting style with a given object\n   * @param {Object|string} obj\n   * @param {*} [obj]\n   */\n  set: function (obj, value) {\n    if (typeof obj === 'string') {\n      this[obj] = value;\n    } else {\n      this.extendFrom(obj, true);\n    }\n  },\n\n  /**\n   * Clone\n   * @return {zrender/graphic/Style} [description]\n   */\n  clone: function () {\n    var newStyle = new this.constructor();\n    newStyle.extendFrom(this, true);\n    return newStyle;\n  },\n  getGradient: function (ctx, obj, rect) {\n    var method = obj.type === 'radial' ? createRadialGradient : createLinearGradient;\n    var canvasGradient = method(ctx, obj, rect);\n    var colorStops = obj.colorStops;\n\n    for (var i = 0; i < colorStops.length; i++) {\n      canvasGradient.addColorStop(colorStops[i].offset, colorStops[i].color);\n    }\n\n    return canvasGradient;\n  }\n};\nvar styleProto = Style.prototype;\n\nfor (var i = 0; i < STYLE_COMMON_PROPS.length; i++) {\n  var prop = STYLE_COMMON_PROPS[i];\n\n  if (!(prop[0] in styleProto)) {\n    styleProto[prop[0]] = prop[1];\n  }\n} // Provide for others\n\n\nStyle.getGradient = styleProto.getGradient;\nvar _default = Style;\nmodule.exports = _default;","/**\n * zrender: 生成唯一id\n *\n * @author errorrik (errorrik@gmail.com)\n */\nvar idStart = 0x0907;\n\nfunction _default() {\n  return idStart++;\n}\n\nmodule.exports = _default;","/**\n * Event Mixin\n * @module zrender/mixin/Eventful\n * @author Kener (@Kener-林峰, kener.linfeng@gmail.com)\n *         pissang (https://www.github.com/pissang)\n */\nvar arrySlice = Array.prototype.slice;\n/**\n * Event dispatcher.\n *\n * @alias module:zrender/mixin/Eventful\n * @constructor\n * @param {Object} [eventProcessor] The object eventProcessor is the scope when\n *        `eventProcessor.xxx` called.\n * @param {Function} [eventProcessor.normalizeQuery]\n *        param: {string|Object} Raw query.\n *        return: {string|Object} Normalized query.\n * @param {Function} [eventProcessor.filter] Event will be dispatched only\n *        if it returns `true`.\n *        param: {string} eventType\n *        param: {string|Object} query\n *        return: {boolean}\n * @param {Function} [eventProcessor.afterTrigger] Call after all handlers called.\n *        param: {string} eventType\n */\n\nvar Eventful = function (eventProcessor) {\n  this._$handlers = {};\n  this._$eventProcessor = eventProcessor;\n};\n\nEventful.prototype = {\n  constructor: Eventful,\n\n  /**\n   * The handler can only be triggered once, then removed.\n   *\n   * @param {string} event The event name.\n   * @param {string|Object} [query] Condition used on event filter.\n   * @param {Function} handler The event handler.\n   * @param {Object} context\n   */\n  one: function (event, query, handler, context) {\n    return on(this, event, query, handler, context, true);\n  },\n\n  /**\n   * Bind a handler.\n   *\n   * @param {string} event The event name.\n   * @param {string|Object} [query] Condition used on event filter.\n   * @param {Function} handler The event handler.\n   * @param {Object} [context]\n   */\n  on: function (event, query, handler, context) {\n    return on(this, event, query, handler, context, false);\n  },\n\n  /**\n   * Whether any handler has bound.\n   *\n   * @param  {string}  event\n   * @return {boolean}\n   */\n  isSilent: function (event) {\n    var _h = this._$handlers;\n    return !_h[event] || !_h[event].length;\n  },\n\n  /**\n   * Unbind a event.\n   *\n   * @param {string} event The event name.\n   * @param {Function} [handler] The event handler.\n   */\n  off: function (event, handler) {\n    var _h = this._$handlers;\n\n    if (!event) {\n      this._$handlers = {};\n      return this;\n    }\n\n    if (handler) {\n      if (_h[event]) {\n        var newList = [];\n\n        for (var i = 0, l = _h[event].length; i < l; i++) {\n          if (_h[event][i].h !== handler) {\n            newList.push(_h[event][i]);\n          }\n        }\n\n        _h[event] = newList;\n      }\n\n      if (_h[event] && _h[event].length === 0) {\n        delete _h[event];\n      }\n    } else {\n      delete _h[event];\n    }\n\n    return this;\n  },\n\n  /**\n   * Dispatch a event.\n   *\n   * @param {string} type The event name.\n   */\n  trigger: function (type) {\n    var _h = this._$handlers[type];\n    var eventProcessor = this._$eventProcessor;\n\n    if (_h) {\n      var args = arguments;\n      var argLen = args.length;\n\n      if (argLen > 3) {\n        args = arrySlice.call(args, 1);\n      }\n\n      var len = _h.length;\n\n      for (var i = 0; i < len;) {\n        var hItem = _h[i];\n\n        if (eventProcessor && eventProcessor.filter && hItem.query != null && !eventProcessor.filter(type, hItem.query)) {\n          i++;\n          continue;\n        } // Optimize advise from backbone\n\n\n        switch (argLen) {\n          case 1:\n            hItem.h.call(hItem.ctx);\n            break;\n\n          case 2:\n            hItem.h.call(hItem.ctx, args[1]);\n            break;\n\n          case 3:\n            hItem.h.call(hItem.ctx, args[1], args[2]);\n            break;\n\n          default:\n            // have more than 2 given arguments\n            hItem.h.apply(hItem.ctx, args);\n            break;\n        }\n\n        if (hItem.one) {\n          _h.splice(i, 1);\n\n          len--;\n        } else {\n          i++;\n        }\n      }\n    }\n\n    eventProcessor && eventProcessor.afterTrigger && eventProcessor.afterTrigger(type);\n    return this;\n  },\n\n  /**\n   * Dispatch a event with context, which is specified at the last parameter.\n   *\n   * @param {string} type The event name.\n   */\n  triggerWithContext: function (type) {\n    var _h = this._$handlers[type];\n    var eventProcessor = this._$eventProcessor;\n\n    if (_h) {\n      var args = arguments;\n      var argLen = args.length;\n\n      if (argLen > 4) {\n        args = arrySlice.call(args, 1, args.length - 1);\n      }\n\n      var ctx = args[args.length - 1];\n      var len = _h.length;\n\n      for (var i = 0; i < len;) {\n        var hItem = _h[i];\n\n        if (eventProcessor && eventProcessor.filter && hItem.query != null && !eventProcessor.filter(type, hItem.query)) {\n          i++;\n          continue;\n        } // Optimize advise from backbone\n\n\n        switch (argLen) {\n          case 1:\n            hItem.h.call(ctx);\n            break;\n\n          case 2:\n            hItem.h.call(ctx, args[1]);\n            break;\n\n          case 3:\n            hItem.h.call(ctx, args[1], args[2]);\n            break;\n\n          default:\n            // have more than 2 given arguments\n            hItem.h.apply(ctx, args);\n            break;\n        }\n\n        if (hItem.one) {\n          _h.splice(i, 1);\n\n          len--;\n        } else {\n          i++;\n        }\n      }\n    }\n\n    eventProcessor && eventProcessor.afterTrigger && eventProcessor.afterTrigger(type);\n    return this;\n  }\n};\n\nfunction normalizeQuery(host, query) {\n  var eventProcessor = host._$eventProcessor;\n\n  if (query != null && eventProcessor && eventProcessor.normalizeQuery) {\n    query = eventProcessor.normalizeQuery(query);\n  }\n\n  return query;\n}\n\nfunction on(eventful, event, query, handler, context, isOnce) {\n  var _h = eventful._$handlers;\n\n  if (typeof query === 'function') {\n    context = handler;\n    handler = query;\n    query = null;\n  }\n\n  if (!handler || !event) {\n    return eventful;\n  }\n\n  query = normalizeQuery(eventful, query);\n\n  if (!_h[event]) {\n    _h[event] = [];\n  }\n\n  for (var i = 0; i < _h[event].length; i++) {\n    if (_h[event][i].h === handler) {\n      return eventful;\n    }\n  }\n\n  var wrap = {\n    h: handler,\n    one: isOnce,\n    query: query,\n    ctx: context || eventful,\n    // FIXME\n    // Do not publish this feature util it is proved that it makes sense.\n    callAtLast: handler.zrEventfulCallAtLast\n  };\n  var lastIndex = _h[event].length - 1;\n  var lastWrap = _h[event][lastIndex];\n  lastWrap && lastWrap.callAtLast ? _h[event].splice(lastIndex, 0, wrap) : _h[event].push(wrap);\n  return eventful;\n} // ----------------------\n// The events in zrender\n// ----------------------\n\n/**\n * @event module:zrender/mixin/Eventful#onclick\n * @type {Function}\n * @default null\n */\n\n/**\n * @event module:zrender/mixin/Eventful#onmouseover\n * @type {Function}\n * @default null\n */\n\n/**\n * @event module:zrender/mixin/Eventful#onmouseout\n * @type {Function}\n * @default null\n */\n\n/**\n * @event module:zrender/mixin/Eventful#onmousemove\n * @type {Function}\n * @default null\n */\n\n/**\n * @event module:zrender/mixin/Eventful#onmousewheel\n * @type {Function}\n * @default null\n */\n\n/**\n * @event module:zrender/mixin/Eventful#onmousedown\n * @type {Function}\n * @default null\n */\n\n/**\n * @event module:zrender/mixin/Eventful#onmouseup\n * @type {Function}\n * @default null\n */\n\n/**\n * @event module:zrender/mixin/Eventful#ondrag\n * @type {Function}\n * @default null\n */\n\n/**\n * @event module:zrender/mixin/Eventful#ondragstart\n * @type {Function}\n * @default null\n */\n\n/**\n * @event module:zrender/mixin/Eventful#ondragend\n * @type {Function}\n * @default null\n */\n\n/**\n * @event module:zrender/mixin/Eventful#ondragenter\n * @type {Function}\n * @default null\n */\n\n/**\n * @event module:zrender/mixin/Eventful#ondragleave\n * @type {Function}\n * @default null\n */\n\n/**\n * @event module:zrender/mixin/Eventful#ondragover\n * @type {Function}\n * @default null\n */\n\n/**\n * @event module:zrender/mixin/Eventful#ondrop\n * @type {Function}\n * @default null\n */\n\n\nvar _default = Eventful;\nmodule.exports = _default;","var Animator = require(\"../animation/Animator\");\n\nvar log = require(\"../core/log\");\n\nvar _util = require(\"../core/util\");\n\nvar isString = _util.isString;\nvar isFunction = _util.isFunction;\nvar isObject = _util.isObject;\nvar isArrayLike = _util.isArrayLike;\nvar indexOf = _util.indexOf;\n\n/**\n * @alias modue:zrender/mixin/Animatable\n * @constructor\n */\nvar Animatable = function () {\n  /**\n   * @type {Array.<module:zrender/animation/Animator>}\n   * @readOnly\n   */\n  this.animators = [];\n};\n\nAnimatable.prototype = {\n  constructor: Animatable,\n\n  /**\n   * 动画\n   *\n   * @param {string} path The path to fetch value from object, like 'a.b.c'.\n   * @param {boolean} [loop] Whether to loop animation.\n   * @return {module:zrender/animation/Animator}\n   * @example:\n   *     el.animate('style', false)\n   *         .when(1000, {x: 10} )\n   *         .done(function(){ // Animation done })\n   *         .start()\n   */\n  animate: function (path, loop) {\n    var target;\n    var animatingShape = false;\n    var el = this;\n    var zr = this.__zr;\n\n    if (path) {\n      var pathSplitted = path.split('.');\n      var prop = el; // If animating shape\n\n      animatingShape = pathSplitted[0] === 'shape';\n\n      for (var i = 0, l = pathSplitted.length; i < l; i++) {\n        if (!prop) {\n          continue;\n        }\n\n        prop = prop[pathSplitted[i]];\n      }\n\n      if (prop) {\n        target = prop;\n      }\n    } else {\n      target = el;\n    }\n\n    if (!target) {\n      log('Property \"' + path + '\" is not existed in element ' + el.id);\n      return;\n    }\n\n    var animators = el.animators;\n    var animator = new Animator(target, loop);\n    animator.during(function (target) {\n      el.dirty(animatingShape);\n    }).done(function () {\n      // FIXME Animator will not be removed if use `Animator#stop` to stop animation\n      animators.splice(indexOf(animators, animator), 1);\n    });\n    animators.push(animator); // If animate after added to the zrender\n\n    if (zr) {\n      zr.animation.addAnimator(animator);\n    }\n\n    return animator;\n  },\n\n  /**\n   * 停止动画\n   * @param {boolean} forwardToLast If move to last frame before stop\n   */\n  stopAnimation: function (forwardToLast) {\n    var animators = this.animators;\n    var len = animators.length;\n\n    for (var i = 0; i < len; i++) {\n      animators[i].stop(forwardToLast);\n    }\n\n    animators.length = 0;\n    return this;\n  },\n\n  /**\n   * Caution: this method will stop previous animation.\n   * So do not use this method to one element twice before\n   * animation starts, unless you know what you are doing.\n   * @param {Object} target\n   * @param {number} [time=500] Time in ms\n   * @param {string} [easing='linear']\n   * @param {number} [delay=0]\n   * @param {Function} [callback]\n   * @param {Function} [forceAnimate] Prevent stop animation and callback\n   *        immediently when target values are the same as current values.\n   *\n   * @example\n   *  // Animate position\n   *  el.animateTo({\n   *      position: [10, 10]\n   *  }, function () { // done })\n   *\n   *  // Animate shape, style and position in 100ms, delayed 100ms, with cubicOut easing\n   *  el.animateTo({\n   *      shape: {\n   *          width: 500\n   *      },\n   *      style: {\n   *          fill: 'red'\n   *      }\n   *      position: [10, 10]\n   *  }, 100, 100, 'cubicOut', function () { // done })\n   */\n  // TODO Return animation key\n  animateTo: function (target, time, delay, easing, callback, forceAnimate) {\n    animateTo(this, target, time, delay, easing, callback, forceAnimate);\n  },\n\n  /**\n   * Animate from the target state to current state.\n   * The params and the return value are the same as `this.animateTo`.\n   */\n  animateFrom: function (target, time, delay, easing, callback, forceAnimate) {\n    animateTo(this, target, time, delay, easing, callback, forceAnimate, true);\n  }\n};\n\nfunction animateTo(animatable, target, time, delay, easing, callback, forceAnimate, reverse) {\n  // animateTo(target, time, easing, callback);\n  if (isString(delay)) {\n    callback = easing;\n    easing = delay;\n    delay = 0;\n  } // animateTo(target, time, delay, callback);\n  else if (isFunction(easing)) {\n      callback = easing;\n      easing = 'linear';\n      delay = 0;\n    } // animateTo(target, time, callback);\n    else if (isFunction(delay)) {\n        callback = delay;\n        delay = 0;\n      } // animateTo(target, callback)\n      else if (isFunction(time)) {\n          callback = time;\n          time = 500;\n        } // animateTo(target)\n        else if (!time) {\n            time = 500;\n          } // Stop all previous animations\n\n\n  animatable.stopAnimation();\n  animateToShallow(animatable, '', animatable, target, time, delay, reverse); // Animators may be removed immediately after start\n  // if there is nothing to animate\n\n  var animators = animatable.animators.slice();\n  var count = animators.length;\n\n  function done() {\n    count--;\n\n    if (!count) {\n      callback && callback();\n    }\n  } // No animators. This should be checked before animators[i].start(),\n  // because 'done' may be executed immediately if no need to animate.\n\n\n  if (!count) {\n    callback && callback();\n  } // Start after all animators created\n  // Incase any animator is done immediately when all animation properties are not changed\n\n\n  for (var i = 0; i < animators.length; i++) {\n    animators[i].done(done).start(easing, forceAnimate);\n  }\n}\n/**\n * @param {string} path=''\n * @param {Object} source=animatable\n * @param {Object} target\n * @param {number} [time=500]\n * @param {number} [delay=0]\n * @param {boolean} [reverse] If `true`, animate\n *        from the `target` to current state.\n *\n * @example\n *  // Animate position\n *  el._animateToShallow({\n *      position: [10, 10]\n *  })\n *\n *  // Animate shape, style and position in 100ms, delayed 100ms\n *  el._animateToShallow({\n *      shape: {\n *          width: 500\n *      },\n *      style: {\n *          fill: 'red'\n *      }\n *      position: [10, 10]\n *  }, 100, 100)\n */\n\n\nfunction animateToShallow(animatable, path, source, target, time, delay, reverse) {\n  var objShallow = {};\n  var propertyCount = 0;\n\n  for (var name in target) {\n    if (!target.hasOwnProperty(name)) {\n      continue;\n    }\n\n    if (source[name] != null) {\n      if (isObject(target[name]) && !isArrayLike(target[name])) {\n        animateToShallow(animatable, path ? path + '.' + name : name, source[name], target[name], time, delay, reverse);\n      } else {\n        if (reverse) {\n          objShallow[name] = source[name];\n          setAttrByPath(animatable, path, name, target[name]);\n        } else {\n          objShallow[name] = target[name];\n        }\n\n        propertyCount++;\n      }\n    } else if (target[name] != null && !reverse) {\n      setAttrByPath(animatable, path, name, target[name]);\n    }\n  }\n\n  if (propertyCount > 0) {\n    animatable.animate(path, false).when(time == null ? 500 : time, objShallow).delay(delay || 0);\n  }\n}\n\nfunction setAttrByPath(el, path, name, value) {\n  // Attr directly if not has property\n  // FIXME, if some property not needed for element ?\n  if (!path) {\n    el.attr(name, value);\n  } else {\n    // Only support set shape or style\n    var props = {};\n    props[path] = {};\n    props[path][name] = value;\n    el.attr(props);\n  }\n}\n\nvar _default = Animatable;\nmodule.exports = _default;","var Clip = require(\"./Clip\");\n\nvar color = require(\"../tool/color\");\n\nvar _util = require(\"../core/util\");\n\nvar isArrayLike = _util.isArrayLike;\n\n/**\n * @module echarts/animation/Animator\n */\nvar arraySlice = Array.prototype.slice;\n\nfunction defaultGetter(target, key) {\n  return target[key];\n}\n\nfunction defaultSetter(target, key, value) {\n  target[key] = value;\n}\n/**\n * @param  {number} p0\n * @param  {number} p1\n * @param  {number} percent\n * @return {number}\n */\n\n\nfunction interpolateNumber(p0, p1, percent) {\n  return (p1 - p0) * percent + p0;\n}\n/**\n * @param  {string} p0\n * @param  {string} p1\n * @param  {number} percent\n * @return {string}\n */\n\n\nfunction interpolateString(p0, p1, percent) {\n  return percent > 0.5 ? p1 : p0;\n}\n/**\n * @param  {Array} p0\n * @param  {Array} p1\n * @param  {number} percent\n * @param  {Array} out\n * @param  {number} arrDim\n */\n\n\nfunction interpolateArray(p0, p1, percent, out, arrDim) {\n  var len = p0.length;\n\n  if (arrDim === 1) {\n    for (var i = 0; i < len; i++) {\n      out[i] = interpolateNumber(p0[i], p1[i], percent);\n    }\n  } else {\n    var len2 = len && p0[0].length;\n\n    for (var i = 0; i < len; i++) {\n      for (var j = 0; j < len2; j++) {\n        out[i][j] = interpolateNumber(p0[i][j], p1[i][j], percent);\n      }\n    }\n  }\n} // arr0 is source array, arr1 is target array.\n// Do some preprocess to avoid error happened when interpolating from arr0 to arr1\n\n\nfunction fillArr(arr0, arr1, arrDim) {\n  var arr0Len = arr0.length;\n  var arr1Len = arr1.length;\n\n  if (arr0Len !== arr1Len) {\n    // FIXME Not work for TypedArray\n    var isPreviousLarger = arr0Len > arr1Len;\n\n    if (isPreviousLarger) {\n      // Cut the previous\n      arr0.length = arr1Len;\n    } else {\n      // Fill the previous\n      for (var i = arr0Len; i < arr1Len; i++) {\n        arr0.push(arrDim === 1 ? arr1[i] : arraySlice.call(arr1[i]));\n      }\n    }\n  } // Handling NaN value\n\n\n  var len2 = arr0[0] && arr0[0].length;\n\n  for (var i = 0; i < arr0.length; i++) {\n    if (arrDim === 1) {\n      if (isNaN(arr0[i])) {\n        arr0[i] = arr1[i];\n      }\n    } else {\n      for (var j = 0; j < len2; j++) {\n        if (isNaN(arr0[i][j])) {\n          arr0[i][j] = arr1[i][j];\n        }\n      }\n    }\n  }\n}\n/**\n * @param  {Array} arr0\n * @param  {Array} arr1\n * @param  {number} arrDim\n * @return {boolean}\n */\n\n\nfunction isArraySame(arr0, arr1, arrDim) {\n  if (arr0 === arr1) {\n    return true;\n  }\n\n  var len = arr0.length;\n\n  if (len !== arr1.length) {\n    return false;\n  }\n\n  if (arrDim === 1) {\n    for (var i = 0; i < len; i++) {\n      if (arr0[i] !== arr1[i]) {\n        return false;\n      }\n    }\n  } else {\n    var len2 = arr0[0].length;\n\n    for (var i = 0; i < len; i++) {\n      for (var j = 0; j < len2; j++) {\n        if (arr0[i][j] !== arr1[i][j]) {\n          return false;\n        }\n      }\n    }\n  }\n\n  return true;\n}\n/**\n * Catmull Rom interpolate array\n * @param  {Array} p0\n * @param  {Array} p1\n * @param  {Array} p2\n * @param  {Array} p3\n * @param  {number} t\n * @param  {number} t2\n * @param  {number} t3\n * @param  {Array} out\n * @param  {number} arrDim\n */\n\n\nfunction catmullRomInterpolateArray(p0, p1, p2, p3, t, t2, t3, out, arrDim) {\n  var len = p0.length;\n\n  if (arrDim === 1) {\n    for (var i = 0; i < len; i++) {\n      out[i] = catmullRomInterpolate(p0[i], p1[i], p2[i], p3[i], t, t2, t3);\n    }\n  } else {\n    var len2 = p0[0].length;\n\n    for (var i = 0; i < len; i++) {\n      for (var j = 0; j < len2; j++) {\n        out[i][j] = catmullRomInterpolate(p0[i][j], p1[i][j], p2[i][j], p3[i][j], t, t2, t3);\n      }\n    }\n  }\n}\n/**\n * Catmull Rom interpolate number\n * @param  {number} p0\n * @param  {number} p1\n * @param  {number} p2\n * @param  {number} p3\n * @param  {number} t\n * @param  {number} t2\n * @param  {number} t3\n * @return {number}\n */\n\n\nfunction catmullRomInterpolate(p0, p1, p2, p3, t, t2, t3) {\n  var v0 = (p2 - p0) * 0.5;\n  var v1 = (p3 - p1) * 0.5;\n  return (2 * (p1 - p2) + v0 + v1) * t3 + (-3 * (p1 - p2) - 2 * v0 - v1) * t2 + v0 * t + p1;\n}\n\nfunction cloneValue(value) {\n  if (isArrayLike(value)) {\n    var len = value.length;\n\n    if (isArrayLike(value[0])) {\n      var ret = [];\n\n      for (var i = 0; i < len; i++) {\n        ret.push(arraySlice.call(value[i]));\n      }\n\n      return ret;\n    }\n\n    return arraySlice.call(value);\n  }\n\n  return value;\n}\n\nfunction rgba2String(rgba) {\n  rgba[0] = Math.floor(rgba[0]);\n  rgba[1] = Math.floor(rgba[1]);\n  rgba[2] = Math.floor(rgba[2]);\n  return 'rgba(' + rgba.join(',') + ')';\n}\n\nfunction getArrayDim(keyframes) {\n  var lastValue = keyframes[keyframes.length - 1].value;\n  return isArrayLike(lastValue && lastValue[0]) ? 2 : 1;\n}\n\nfunction createTrackClip(animator, easing, oneTrackDone, keyframes, propName, forceAnimate) {\n  var getter = animator._getter;\n  var setter = animator._setter;\n  var useSpline = easing === 'spline';\n  var trackLen = keyframes.length;\n\n  if (!trackLen) {\n    return;\n  } // Guess data type\n\n\n  var firstVal = keyframes[0].value;\n  var isValueArray = isArrayLike(firstVal);\n  var isValueColor = false;\n  var isValueString = false; // For vertices morphing\n\n  var arrDim = isValueArray ? getArrayDim(keyframes) : 0;\n  var trackMaxTime; // Sort keyframe as ascending\n\n  keyframes.sort(function (a, b) {\n    return a.time - b.time;\n  });\n  trackMaxTime = keyframes[trackLen - 1].time; // Percents of each keyframe\n\n  var kfPercents = []; // Value of each keyframe\n\n  var kfValues = [];\n  var prevValue = keyframes[0].value;\n  var isAllValueEqual = true;\n\n  for (var i = 0; i < trackLen; i++) {\n    kfPercents.push(keyframes[i].time / trackMaxTime); // Assume value is a color when it is a string\n\n    var value = keyframes[i].value; // Check if value is equal, deep check if value is array\n\n    if (!(isValueArray && isArraySame(value, prevValue, arrDim) || !isValueArray && value === prevValue)) {\n      isAllValueEqual = false;\n    }\n\n    prevValue = value; // Try converting a string to a color array\n\n    if (typeof value === 'string') {\n      var colorArray = color.parse(value);\n\n      if (colorArray) {\n        value = colorArray;\n        isValueColor = true;\n      } else {\n        isValueString = true;\n      }\n    }\n\n    kfValues.push(value);\n  }\n\n  if (!forceAnimate && isAllValueEqual) {\n    return;\n  }\n\n  var lastValue = kfValues[trackLen - 1]; // Polyfill array and NaN value\n\n  for (var i = 0; i < trackLen - 1; i++) {\n    if (isValueArray) {\n      fillArr(kfValues[i], lastValue, arrDim);\n    } else {\n      if (isNaN(kfValues[i]) && !isNaN(lastValue) && !isValueString && !isValueColor) {\n        kfValues[i] = lastValue;\n      }\n    }\n  }\n\n  isValueArray && fillArr(getter(animator._target, propName), lastValue, arrDim); // Cache the key of last frame to speed up when\n  // animation playback is sequency\n\n  var lastFrame = 0;\n  var lastFramePercent = 0;\n  var start;\n  var w;\n  var p0;\n  var p1;\n  var p2;\n  var p3;\n\n  if (isValueColor) {\n    var rgba = [0, 0, 0, 0];\n  }\n\n  var onframe = function (target, percent) {\n    // Find the range keyframes\n    // kf1-----kf2---------current--------kf3\n    // find kf2 and kf3 and do interpolation\n    var frame; // In the easing function like elasticOut, percent may less than 0\n\n    if (percent < 0) {\n      frame = 0;\n    } else if (percent < lastFramePercent) {\n      // Start from next key\n      // PENDING start from lastFrame ?\n      start = Math.min(lastFrame + 1, trackLen - 1);\n\n      for (frame = start; frame >= 0; frame--) {\n        if (kfPercents[frame] <= percent) {\n          break;\n        }\n      } // PENDING really need to do this ?\n\n\n      frame = Math.min(frame, trackLen - 2);\n    } else {\n      for (frame = lastFrame; frame < trackLen; frame++) {\n        if (kfPercents[frame] > percent) {\n          break;\n        }\n      }\n\n      frame = Math.min(frame - 1, trackLen - 2);\n    }\n\n    lastFrame = frame;\n    lastFramePercent = percent;\n    var range = kfPercents[frame + 1] - kfPercents[frame];\n\n    if (range === 0) {\n      return;\n    } else {\n      w = (percent - kfPercents[frame]) / range;\n    }\n\n    if (useSpline) {\n      p1 = kfValues[frame];\n      p0 = kfValues[frame === 0 ? frame : frame - 1];\n      p2 = kfValues[frame > trackLen - 2 ? trackLen - 1 : frame + 1];\n      p3 = kfValues[frame > trackLen - 3 ? trackLen - 1 : frame + 2];\n\n      if (isValueArray) {\n        catmullRomInterpolateArray(p0, p1, p2, p3, w, w * w, w * w * w, getter(target, propName), arrDim);\n      } else {\n        var value;\n\n        if (isValueColor) {\n          value = catmullRomInterpolateArray(p0, p1, p2, p3, w, w * w, w * w * w, rgba, 1);\n          value = rgba2String(rgba);\n        } else if (isValueString) {\n          // String is step(0.5)\n          return interpolateString(p1, p2, w);\n        } else {\n          value = catmullRomInterpolate(p0, p1, p2, p3, w, w * w, w * w * w);\n        }\n\n        setter(target, propName, value);\n      }\n    } else {\n      if (isValueArray) {\n        interpolateArray(kfValues[frame], kfValues[frame + 1], w, getter(target, propName), arrDim);\n      } else {\n        var value;\n\n        if (isValueColor) {\n          interpolateArray(kfValues[frame], kfValues[frame + 1], w, rgba, 1);\n          value = rgba2String(rgba);\n        } else if (isValueString) {\n          // String is step(0.5)\n          return interpolateString(kfValues[frame], kfValues[frame + 1], w);\n        } else {\n          value = interpolateNumber(kfValues[frame], kfValues[frame + 1], w);\n        }\n\n        setter(target, propName, value);\n      }\n    }\n  };\n\n  var clip = new Clip({\n    target: animator._target,\n    life: trackMaxTime,\n    loop: animator._loop,\n    delay: animator._delay,\n    onframe: onframe,\n    ondestroy: oneTrackDone\n  });\n\n  if (easing && easing !== 'spline') {\n    clip.easing = easing;\n  }\n\n  return clip;\n}\n/**\n * @alias module:zrender/animation/Animator\n * @constructor\n * @param {Object} target\n * @param {boolean} loop\n * @param {Function} getter\n * @param {Function} setter\n */\n\n\nvar Animator = function (target, loop, getter, setter) {\n  this._tracks = {};\n  this._target = target;\n  this._loop = loop || false;\n  this._getter = getter || defaultGetter;\n  this._setter = setter || defaultSetter;\n  this._clipCount = 0;\n  this._delay = 0;\n  this._doneList = [];\n  this._onframeList = [];\n  this._clipList = [];\n};\n\nAnimator.prototype = {\n  /**\n   * 设置动画关键帧\n   * @param  {number} time 关键帧时间，单位是ms\n   * @param  {Object} props 关键帧的属性值，key-value表示\n   * @return {module:zrender/animation/Animator}\n   */\n  when: function (time\n  /* ms */\n  , props) {\n    var tracks = this._tracks;\n\n    for (var propName in props) {\n      if (!props.hasOwnProperty(propName)) {\n        continue;\n      }\n\n      if (!tracks[propName]) {\n        tracks[propName] = []; // Invalid value\n\n        var value = this._getter(this._target, propName);\n\n        if (value == null) {\n          // zrLog('Invalid property ' + propName);\n          continue;\n        } // If time is 0\n        //  Then props is given initialize value\n        // Else\n        //  Initialize value from current prop value\n\n\n        if (time !== 0) {\n          tracks[propName].push({\n            time: 0,\n            value: cloneValue(value)\n          });\n        }\n      }\n\n      tracks[propName].push({\n        time: time,\n        value: props[propName]\n      });\n    }\n\n    return this;\n  },\n\n  /**\n   * 添加动画每一帧的回调函数\n   * @param  {Function} callback\n   * @return {module:zrender/animation/Animator}\n   */\n  during: function (callback) {\n    this._onframeList.push(callback);\n\n    return this;\n  },\n  pause: function () {\n    for (var i = 0; i < this._clipList.length; i++) {\n      this._clipList[i].pause();\n    }\n\n    this._paused = true;\n  },\n  resume: function () {\n    for (var i = 0; i < this._clipList.length; i++) {\n      this._clipList[i].resume();\n    }\n\n    this._paused = false;\n  },\n  isPaused: function () {\n    return !!this._paused;\n  },\n  _doneCallback: function () {\n    // Clear all tracks\n    this._tracks = {}; // Clear all clips\n\n    this._clipList.length = 0;\n    var doneList = this._doneList;\n    var len = doneList.length;\n\n    for (var i = 0; i < len; i++) {\n      doneList[i].call(this);\n    }\n  },\n\n  /**\n   * 开始执行动画\n   * @param  {string|Function} [easing]\n   *         动画缓动函数，详见{@link module:zrender/animation/easing}\n   * @param  {boolean} forceAnimate\n   * @return {module:zrender/animation/Animator}\n   */\n  start: function (easing, forceAnimate) {\n    var self = this;\n    var clipCount = 0;\n\n    var oneTrackDone = function () {\n      clipCount--;\n\n      if (!clipCount) {\n        self._doneCallback();\n      }\n    };\n\n    var lastClip;\n\n    for (var propName in this._tracks) {\n      if (!this._tracks.hasOwnProperty(propName)) {\n        continue;\n      }\n\n      var clip = createTrackClip(this, easing, oneTrackDone, this._tracks[propName], propName, forceAnimate);\n\n      if (clip) {\n        this._clipList.push(clip);\n\n        clipCount++; // If start after added to animation\n\n        if (this.animation) {\n          this.animation.addClip(clip);\n        }\n\n        lastClip = clip;\n      }\n    } // Add during callback on the last clip\n\n\n    if (lastClip) {\n      var oldOnFrame = lastClip.onframe;\n\n      lastClip.onframe = function (target, percent) {\n        oldOnFrame(target, percent);\n\n        for (var i = 0; i < self._onframeList.length; i++) {\n          self._onframeList[i](target, percent);\n        }\n      };\n    } // This optimization will help the case that in the upper application\n    // the view may be refreshed frequently, where animation will be\n    // called repeatly but nothing changed.\n\n\n    if (!clipCount) {\n      this._doneCallback();\n    }\n\n    return this;\n  },\n\n  /**\n   * 停止动画\n   * @param {boolean} forwardToLast If move to last frame before stop\n   */\n  stop: function (forwardToLast) {\n    var clipList = this._clipList;\n    var animation = this.animation;\n\n    for (var i = 0; i < clipList.length; i++) {\n      var clip = clipList[i];\n\n      if (forwardToLast) {\n        // Move to last frame before stop\n        clip.onframe(this._target, 1);\n      }\n\n      animation && animation.removeClip(clip);\n    }\n\n    clipList.length = 0;\n  },\n\n  /**\n   * 设置动画延迟开始的时间\n   * @param  {number} time 单位ms\n   * @return {module:zrender/animation/Animator}\n   */\n  delay: function (time) {\n    this._delay = time;\n    return this;\n  },\n\n  /**\n   * 添加动画结束的回调\n   * @param  {Function} cb\n   * @return {module:zrender/animation/Animator}\n   */\n  done: function (cb) {\n    if (cb) {\n      this._doneList.push(cb);\n    }\n\n    return this;\n  },\n\n  /**\n   * @return {Array.<module:zrender/animation/Clip>}\n   */\n  getClips: function () {\n    return this._clipList;\n  }\n};\nvar _default = Animator;\nmodule.exports = _default;","var easingFuncs = require(\"./easing\");\n\n/**\n * 动画主控制器\n * @config target 动画对象，可以是数组，如果是数组的话会批量分发onframe等事件\n * @config life(1000) 动画时长\n * @config delay(0) 动画延迟时间\n * @config loop(true)\n * @config gap(0) 循环的间隔时间\n * @config onframe\n * @config easing(optional)\n * @config ondestroy(optional)\n * @config onrestart(optional)\n *\n * TODO pause\n */\nfunction Clip(options) {\n  this._target = options.target; // 生命周期\n\n  this._life = options.life || 1000; // 延时\n\n  this._delay = options.delay || 0; // 开始时间\n  // this._startTime = new Date().getTime() + this._delay;// 单位毫秒\n\n  this._initialized = false; // 是否循环\n\n  this.loop = options.loop == null ? false : options.loop;\n  this.gap = options.gap || 0;\n  this.easing = options.easing || 'Linear';\n  this.onframe = options.onframe;\n  this.ondestroy = options.ondestroy;\n  this.onrestart = options.onrestart;\n  this._pausedTime = 0;\n  this._paused = false;\n}\n\nClip.prototype = {\n  constructor: Clip,\n  step: function (globalTime, deltaTime) {\n    // Set startTime on first step, or _startTime may has milleseconds different between clips\n    // PENDING\n    if (!this._initialized) {\n      this._startTime = globalTime + this._delay;\n      this._initialized = true;\n    }\n\n    if (this._paused) {\n      this._pausedTime += deltaTime;\n      return;\n    }\n\n    var percent = (globalTime - this._startTime - this._pausedTime) / this._life; // 还没开始\n\n    if (percent < 0) {\n      return;\n    }\n\n    percent = Math.min(percent, 1);\n    var easing = this.easing;\n    var easingFunc = typeof easing === 'string' ? easingFuncs[easing] : easing;\n    var schedule = typeof easingFunc === 'function' ? easingFunc(percent) : percent;\n    this.fire('frame', schedule); // 结束\n\n    if (percent === 1) {\n      if (this.loop) {\n        this.restart(globalTime); // 重新开始周期\n        // 抛出而不是直接调用事件直到 stage.update 后再统一调用这些事件\n\n        return 'restart';\n      } // 动画完成将这个控制器标识为待删除\n      // 在Animation.update中进行批量删除\n\n\n      this._needsRemove = true;\n      return 'destroy';\n    }\n\n    return null;\n  },\n  restart: function (globalTime) {\n    var remainder = (globalTime - this._startTime - this._pausedTime) % this._life;\n    this._startTime = globalTime - remainder + this.gap;\n    this._pausedTime = 0;\n    this._needsRemove = false;\n  },\n  fire: function (eventType, arg) {\n    eventType = 'on' + eventType;\n\n    if (this[eventType]) {\n      this[eventType](this._target, arg);\n    }\n  },\n  pause: function () {\n    this._paused = true;\n  },\n  resume: function () {\n    this._paused = false;\n  }\n};\nvar _default = Clip;\nmodule.exports = _default;","/**\n * 缓动代码来自 https://github.com/sole/tween.js/blob/master/src/Tween.js\n * @see http://sole.github.io/tween.js/examples/03_graphs.html\n * @exports zrender/animation/easing\n */\nvar easing = {\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  linear: function (k) {\n    return k;\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  quadraticIn: function (k) {\n    return k * k;\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  quadraticOut: function (k) {\n    return k * (2 - k);\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  quadraticInOut: function (k) {\n    if ((k *= 2) < 1) {\n      return 0.5 * k * k;\n    }\n\n    return -0.5 * (--k * (k - 2) - 1);\n  },\n  // 三次方的缓动（t^3）\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  cubicIn: function (k) {\n    return k * k * k;\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  cubicOut: function (k) {\n    return --k * k * k + 1;\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  cubicInOut: function (k) {\n    if ((k *= 2) < 1) {\n      return 0.5 * k * k * k;\n    }\n\n    return 0.5 * ((k -= 2) * k * k + 2);\n  },\n  // 四次方的缓动（t^4）\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  quarticIn: function (k) {\n    return k * k * k * k;\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  quarticOut: function (k) {\n    return 1 - --k * k * k * k;\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  quarticInOut: function (k) {\n    if ((k *= 2) < 1) {\n      return 0.5 * k * k * k * k;\n    }\n\n    return -0.5 * ((k -= 2) * k * k * k - 2);\n  },\n  // 五次方的缓动（t^5）\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  quinticIn: function (k) {\n    return k * k * k * k * k;\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  quinticOut: function (k) {\n    return --k * k * k * k * k + 1;\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  quinticInOut: function (k) {\n    if ((k *= 2) < 1) {\n      return 0.5 * k * k * k * k * k;\n    }\n\n    return 0.5 * ((k -= 2) * k * k * k * k + 2);\n  },\n  // 正弦曲线的缓动（sin(t)）\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  sinusoidalIn: function (k) {\n    return 1 - Math.cos(k * Math.PI / 2);\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  sinusoidalOut: function (k) {\n    return Math.sin(k * Math.PI / 2);\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  sinusoidalInOut: function (k) {\n    return 0.5 * (1 - Math.cos(Math.PI * k));\n  },\n  // 指数曲线的缓动（2^t）\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  exponentialIn: function (k) {\n    return k === 0 ? 0 : Math.pow(1024, k - 1);\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  exponentialOut: function (k) {\n    return k === 1 ? 1 : 1 - Math.pow(2, -10 * k);\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  exponentialInOut: function (k) {\n    if (k === 0) {\n      return 0;\n    }\n\n    if (k === 1) {\n      return 1;\n    }\n\n    if ((k *= 2) < 1) {\n      return 0.5 * Math.pow(1024, k - 1);\n    }\n\n    return 0.5 * (-Math.pow(2, -10 * (k - 1)) + 2);\n  },\n  // 圆形曲线的缓动（sqrt(1-t^2)）\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  circularIn: function (k) {\n    return 1 - Math.sqrt(1 - k * k);\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  circularOut: function (k) {\n    return Math.sqrt(1 - --k * k);\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  circularInOut: function (k) {\n    if ((k *= 2) < 1) {\n      return -0.5 * (Math.sqrt(1 - k * k) - 1);\n    }\n\n    return 0.5 * (Math.sqrt(1 - (k -= 2) * k) + 1);\n  },\n  // 创建类似于弹簧在停止前来回振荡的动画\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  elasticIn: function (k) {\n    var s;\n    var a = 0.1;\n    var p = 0.4;\n\n    if (k === 0) {\n      return 0;\n    }\n\n    if (k === 1) {\n      return 1;\n    }\n\n    if (!a || a < 1) {\n      a = 1;\n      s = p / 4;\n    } else {\n      s = p * Math.asin(1 / a) / (2 * Math.PI);\n    }\n\n    return -(a * Math.pow(2, 10 * (k -= 1)) * Math.sin((k - s) * (2 * Math.PI) / p));\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  elasticOut: function (k) {\n    var s;\n    var a = 0.1;\n    var p = 0.4;\n\n    if (k === 0) {\n      return 0;\n    }\n\n    if (k === 1) {\n      return 1;\n    }\n\n    if (!a || a < 1) {\n      a = 1;\n      s = p / 4;\n    } else {\n      s = p * Math.asin(1 / a) / (2 * Math.PI);\n    }\n\n    return a * Math.pow(2, -10 * k) * Math.sin((k - s) * (2 * Math.PI) / p) + 1;\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  elasticInOut: function (k) {\n    var s;\n    var a = 0.1;\n    var p = 0.4;\n\n    if (k === 0) {\n      return 0;\n    }\n\n    if (k === 1) {\n      return 1;\n    }\n\n    if (!a || a < 1) {\n      a = 1;\n      s = p / 4;\n    } else {\n      s = p * Math.asin(1 / a) / (2 * Math.PI);\n    }\n\n    if ((k *= 2) < 1) {\n      return -0.5 * (a * Math.pow(2, 10 * (k -= 1)) * Math.sin((k - s) * (2 * Math.PI) / p));\n    }\n\n    return a * Math.pow(2, -10 * (k -= 1)) * Math.sin((k - s) * (2 * Math.PI) / p) * 0.5 + 1;\n  },\n  // 在某一动画开始沿指示的路径进行动画处理前稍稍收回该动画的移动\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  backIn: function (k) {\n    var s = 1.70158;\n    return k * k * ((s + 1) * k - s);\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  backOut: function (k) {\n    var s = 1.70158;\n    return --k * k * ((s + 1) * k + s) + 1;\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  backInOut: function (k) {\n    var s = 1.70158 * 1.525;\n\n    if ((k *= 2) < 1) {\n      return 0.5 * (k * k * ((s + 1) * k - s));\n    }\n\n    return 0.5 * ((k -= 2) * k * ((s + 1) * k + s) + 2);\n  },\n  // 创建弹跳效果\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  bounceIn: function (k) {\n    return 1 - easing.bounceOut(1 - k);\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  bounceOut: function (k) {\n    if (k < 1 / 2.75) {\n      return 7.5625 * k * k;\n    } else if (k < 2 / 2.75) {\n      return 7.5625 * (k -= 1.5 / 2.75) * k + 0.75;\n    } else if (k < 2.5 / 2.75) {\n      return 7.5625 * (k -= 2.25 / 2.75) * k + 0.9375;\n    } else {\n      return 7.5625 * (k -= 2.625 / 2.75) * k + 0.984375;\n    }\n  },\n\n  /**\n  * @param {number} k\n  * @return {number}\n  */\n  bounceInOut: function (k) {\n    if (k < 0.5) {\n      return easing.bounceIn(k * 2) * 0.5;\n    }\n\n    return easing.bounceOut(k * 2 - 1) * 0.5 + 0.5;\n  }\n};\nvar _default = easing;\nmodule.exports = _default;","var _config = require(\"../config\");\n\nvar debugMode = _config.debugMode;\n\nvar log = function () {};\n\nif (debugMode === 1) {\n  log = function () {\n    for (var k in arguments) {\n      throw new Error(arguments[k]);\n    }\n  };\n} else if (debugMode > 1) {\n  log = function () {\n    for (var k in arguments) {\n      console.log(arguments[k]);\n    }\n  };\n}\n\nvar _default = log;\nmodule.exports = _default;","var textHelper = require(\"../helper/text\");\n\nvar BoundingRect = require(\"../../core/BoundingRect\");\n\nvar _constant = require(\"../constant\");\n\nvar WILL_BE_RESTORED = _constant.WILL_BE_RESTORED;\n\n/**\n * Mixin for drawing text in a element bounding rect\n * @module zrender/mixin/RectText\n */\nvar tmpRect = new BoundingRect();\n\nvar RectText = function () {};\n\nRectText.prototype = {\n  constructor: RectText,\n\n  /**\n   * Draw text in a rect with specified position.\n   * @param  {CanvasRenderingContext2D} ctx\n   * @param  {Object} rect Displayable rect\n   */\n  drawRectText: function (ctx, rect) {\n    var style = this.style;\n    rect = style.textRect || rect; // Optimize, avoid normalize every time.\n\n    this.__dirty && textHelper.normalizeTextStyle(style, true);\n    var text = style.text; // Convert to string\n\n    text != null && (text += '');\n\n    if (!textHelper.needDrawText(text, style)) {\n      return;\n    } // FIXME\n    // Do not provide prevEl to `textHelper.renderText` for ctx prop cache,\n    // but use `ctx.save()` and `ctx.restore()`. Because the cache for rect\n    // text propably break the cache for its host elements.\n\n\n    ctx.save(); // Transform rect to view space\n\n    var transform = this.transform;\n\n    if (!style.transformText) {\n      if (transform) {\n        tmpRect.copy(rect);\n        tmpRect.applyTransform(transform);\n        rect = tmpRect;\n      }\n    } else {\n      this.setTransform(ctx);\n    } // transformText and textRotation can not be used at the same time.\n\n\n    textHelper.renderText(this, ctx, text, style, rect, WILL_BE_RESTORED);\n    ctx.restore();\n  }\n};\nvar _default = RectText;\nmodule.exports = _default;","var vec2 = require(\"./vector\");\n\nvar curve = require(\"./curve\");\n\n/**\n * @author Yi Shen(https://github.com/pissang)\n */\nvar mathMin = Math.min;\nvar mathMax = Math.max;\nvar mathSin = Math.sin;\nvar mathCos = Math.cos;\nvar PI2 = Math.PI * 2;\nvar start = vec2.create();\nvar end = vec2.create();\nvar extremity = vec2.create();\n/**\n * 从顶点数组中计算出最小包围盒，写入`min`和`max`中\n * @module zrender/core/bbox\n * @param {Array<Object>} points 顶点数组\n * @param {number} min\n * @param {number} max\n */\n\nfunction fromPoints(points, min, max) {\n  if (points.length === 0) {\n    return;\n  }\n\n  var p = points[0];\n  var left = p[0];\n  var right = p[0];\n  var top = p[1];\n  var bottom = p[1];\n  var i;\n\n  for (i = 1; i < points.length; i++) {\n    p = points[i];\n    left = mathMin(left, p[0]);\n    right = mathMax(right, p[0]);\n    top = mathMin(top, p[1]);\n    bottom = mathMax(bottom, p[1]);\n  }\n\n  min[0] = left;\n  min[1] = top;\n  max[0] = right;\n  max[1] = bottom;\n}\n/**\n * @memberOf module:zrender/core/bbox\n * @param {number} x0\n * @param {number} y0\n * @param {number} x1\n * @param {number} y1\n * @param {Array.<number>} min\n * @param {Array.<number>} max\n */\n\n\nfunction fromLine(x0, y0, x1, y1, min, max) {\n  min[0] = mathMin(x0, x1);\n  min[1] = mathMin(y0, y1);\n  max[0] = mathMax(x0, x1);\n  max[1] = mathMax(y0, y1);\n}\n\nvar xDim = [];\nvar yDim = [];\n/**\n * 从三阶贝塞尔曲线(p0, p1, p2, p3)中计算出最小包围盒，写入`min`和`max`中\n * @memberOf module:zrender/core/bbox\n * @param {number} x0\n * @param {number} y0\n * @param {number} x1\n * @param {number} y1\n * @param {number} x2\n * @param {number} y2\n * @param {number} x3\n * @param {number} y3\n * @param {Array.<number>} min\n * @param {Array.<number>} max\n */\n\nfunction fromCubic(x0, y0, x1, y1, x2, y2, x3, y3, min, max) {\n  var cubicExtrema = curve.cubicExtrema;\n  var cubicAt = curve.cubicAt;\n  var i;\n  var n = cubicExtrema(x0, x1, x2, x3, xDim);\n  min[0] = Infinity;\n  min[1] = Infinity;\n  max[0] = -Infinity;\n  max[1] = -Infinity;\n\n  for (i = 0; i < n; i++) {\n    var x = cubicAt(x0, x1, x2, x3, xDim[i]);\n    min[0] = mathMin(x, min[0]);\n    max[0] = mathMax(x, max[0]);\n  }\n\n  n = cubicExtrema(y0, y1, y2, y3, yDim);\n\n  for (i = 0; i < n; i++) {\n    var y = cubicAt(y0, y1, y2, y3, yDim[i]);\n    min[1] = mathMin(y, min[1]);\n    max[1] = mathMax(y, max[1]);\n  }\n\n  min[0] = mathMin(x0, min[0]);\n  max[0] = mathMax(x0, max[0]);\n  min[0] = mathMin(x3, min[0]);\n  max[0] = mathMax(x3, max[0]);\n  min[1] = mathMin(y0, min[1]);\n  max[1] = mathMax(y0, max[1]);\n  min[1] = mathMin(y3, min[1]);\n  max[1] = mathMax(y3, max[1]);\n}\n/**\n * 从二阶贝塞尔曲线(p0, p1, p2)中计算出最小包围盒，写入`min`和`max`中\n * @memberOf module:zrender/core/bbox\n * @param {number} x0\n * @param {number} y0\n * @param {number} x1\n * @param {number} y1\n * @param {number} x2\n * @param {number} y2\n * @param {Array.<number>} min\n * @param {Array.<number>} max\n */\n\n\nfunction fromQuadratic(x0, y0, x1, y1, x2, y2, min, max) {\n  var quadraticExtremum = curve.quadraticExtremum;\n  var quadraticAt = curve.quadraticAt; // Find extremities, where derivative in x dim or y dim is zero\n\n  var tx = mathMax(mathMin(quadraticExtremum(x0, x1, x2), 1), 0);\n  var ty = mathMax(mathMin(quadraticExtremum(y0, y1, y2), 1), 0);\n  var x = quadraticAt(x0, x1, x2, tx);\n  var y = quadraticAt(y0, y1, y2, ty);\n  min[0] = mathMin(x0, x2, x);\n  min[1] = mathMin(y0, y2, y);\n  max[0] = mathMax(x0, x2, x);\n  max[1] = mathMax(y0, y2, y);\n}\n/**\n * 从圆弧中计算出最小包围盒，写入`min`和`max`中\n * @method\n * @memberOf module:zrender/core/bbox\n * @param {number} x\n * @param {number} y\n * @param {number} rx\n * @param {number} ry\n * @param {number} startAngle\n * @param {number} endAngle\n * @param {number} anticlockwise\n * @param {Array.<number>} min\n * @param {Array.<number>} max\n */\n\n\nfunction fromArc(x, y, rx, ry, startAngle, endAngle, anticlockwise, min, max) {\n  var vec2Min = vec2.min;\n  var vec2Max = vec2.max;\n  var diff = Math.abs(startAngle - endAngle);\n\n  if (diff % PI2 < 1e-4 && diff > 1e-4) {\n    // Is a circle\n    min[0] = x - rx;\n    min[1] = y - ry;\n    max[0] = x + rx;\n    max[1] = y + ry;\n    return;\n  }\n\n  start[0] = mathCos(startAngle) * rx + x;\n  start[1] = mathSin(startAngle) * ry + y;\n  end[0] = mathCos(endAngle) * rx + x;\n  end[1] = mathSin(endAngle) * ry + y;\n  vec2Min(min, start, end);\n  vec2Max(max, start, end); // Thresh to [0, Math.PI * 2]\n\n  startAngle = startAngle % PI2;\n\n  if (startAngle < 0) {\n    startAngle = startAngle + PI2;\n  }\n\n  endAngle = endAngle % PI2;\n\n  if (endAngle < 0) {\n    endAngle = endAngle + PI2;\n  }\n\n  if (startAngle > endAngle && !anticlockwise) {\n    endAngle += PI2;\n  } else if (startAngle < endAngle && anticlockwise) {\n    startAngle += PI2;\n  }\n\n  if (anticlockwise) {\n    var tmp = endAngle;\n    endAngle = startAngle;\n    startAngle = tmp;\n  } // var number = 0;\n  // var step = (anticlockwise ? -Math.PI : Math.PI) / 2;\n\n\n  for (var angle = 0; angle < endAngle; angle += Math.PI / 2) {\n    if (angle > startAngle) {\n      extremity[0] = mathCos(angle) * rx + x;\n      extremity[1] = mathSin(angle) * ry + y;\n      vec2Min(min, extremity, min);\n      vec2Max(max, extremity, max);\n    }\n  }\n}\n\nexports.fromPoints = fromPoints;\nexports.fromLine = fromLine;\nexports.fromCubic = fromCubic;\nexports.fromQuadratic = fromQuadratic;\nexports.fromArc = fromArc;","var PathProxy = require(\"../core/PathProxy\");\n\nvar line = require(\"./line\");\n\nvar cubic = require(\"./cubic\");\n\nvar quadratic = require(\"./quadratic\");\n\nvar arc = require(\"./arc\");\n\nvar _util = require(\"./util\");\n\nvar normalizeRadian = _util.normalizeRadian;\n\nvar curve = require(\"../core/curve\");\n\nvar windingLine = require(\"./windingLine\");\n\nvar CMD = PathProxy.CMD;\nvar PI2 = Math.PI * 2;\nvar EPSILON = 1e-4;\n\nfunction isAroundEqual(a, b) {\n  return Math.abs(a - b) < EPSILON;\n} // 临时数组\n\n\nvar roots = [-1, -1, -1];\nvar extrema = [-1, -1];\n\nfunction swapExtrema() {\n  var tmp = extrema[0];\n  extrema[0] = extrema[1];\n  extrema[1] = tmp;\n}\n\nfunction windingCubic(x0, y0, x1, y1, x2, y2, x3, y3, x, y) {\n  // Quick reject\n  if (y > y0 && y > y1 && y > y2 && y > y3 || y < y0 && y < y1 && y < y2 && y < y3) {\n    return 0;\n  }\n\n  var nRoots = curve.cubicRootAt(y0, y1, y2, y3, y, roots);\n\n  if (nRoots === 0) {\n    return 0;\n  } else {\n    var w = 0;\n    var nExtrema = -1;\n    var y0_;\n    var y1_;\n\n    for (var i = 0; i < nRoots; i++) {\n      var t = roots[i]; // Avoid winding error when intersection point is the connect point of two line of polygon\n\n      var unit = t === 0 || t === 1 ? 0.5 : 1;\n      var x_ = curve.cubicAt(x0, x1, x2, x3, t);\n\n      if (x_ < x) {\n        // Quick reject\n        continue;\n      }\n\n      if (nExtrema < 0) {\n        nExtrema = curve.cubicExtrema(y0, y1, y2, y3, extrema);\n\n        if (extrema[1] < extrema[0] && nExtrema > 1) {\n          swapExtrema();\n        }\n\n        y0_ = curve.cubicAt(y0, y1, y2, y3, extrema[0]);\n\n        if (nExtrema > 1) {\n          y1_ = curve.cubicAt(y0, y1, y2, y3, extrema[1]);\n        }\n      }\n\n      if (nExtrema === 2) {\n        // 分成三段单调函数\n        if (t < extrema[0]) {\n          w += y0_ < y0 ? unit : -unit;\n        } else if (t < extrema[1]) {\n          w += y1_ < y0_ ? unit : -unit;\n        } else {\n          w += y3 < y1_ ? unit : -unit;\n        }\n      } else {\n        // 分成两段单调函数\n        if (t < extrema[0]) {\n          w += y0_ < y0 ? unit : -unit;\n        } else {\n          w += y3 < y0_ ? unit : -unit;\n        }\n      }\n    }\n\n    return w;\n  }\n}\n\nfunction windingQuadratic(x0, y0, x1, y1, x2, y2, x, y) {\n  // Quick reject\n  if (y > y0 && y > y1 && y > y2 || y < y0 && y < y1 && y < y2) {\n    return 0;\n  }\n\n  var nRoots = curve.quadraticRootAt(y0, y1, y2, y, roots);\n\n  if (nRoots === 0) {\n    return 0;\n  } else {\n    var t = curve.quadraticExtremum(y0, y1, y2);\n\n    if (t >= 0 && t <= 1) {\n      var w = 0;\n      var y_ = curve.quadraticAt(y0, y1, y2, t);\n\n      for (var i = 0; i < nRoots; i++) {\n        // Remove one endpoint.\n        var unit = roots[i] === 0 || roots[i] === 1 ? 0.5 : 1;\n        var x_ = curve.quadraticAt(x0, x1, x2, roots[i]);\n\n        if (x_ < x) {\n          // Quick reject\n          continue;\n        }\n\n        if (roots[i] < t) {\n          w += y_ < y0 ? unit : -unit;\n        } else {\n          w += y2 < y_ ? unit : -unit;\n        }\n      }\n\n      return w;\n    } else {\n      // Remove one endpoint.\n      var unit = roots[0] === 0 || roots[0] === 1 ? 0.5 : 1;\n      var x_ = curve.quadraticAt(x0, x1, x2, roots[0]);\n\n      if (x_ < x) {\n        // Quick reject\n        return 0;\n      }\n\n      return y2 < y0 ? unit : -unit;\n    }\n  }\n} // TODO\n// Arc 旋转\n\n\nfunction windingArc(cx, cy, r, startAngle, endAngle, anticlockwise, x, y) {\n  y -= cy;\n\n  if (y > r || y < -r) {\n    return 0;\n  }\n\n  var tmp = Math.sqrt(r * r - y * y);\n  roots[0] = -tmp;\n  roots[1] = tmp;\n  var diff = Math.abs(startAngle - endAngle);\n\n  if (diff < 1e-4) {\n    return 0;\n  }\n\n  if (diff % PI2 < 1e-4) {\n    // Is a circle\n    startAngle = 0;\n    endAngle = PI2;\n    var dir = anticlockwise ? 1 : -1;\n\n    if (x >= roots[0] + cx && x <= roots[1] + cx) {\n      return dir;\n    } else {\n      return 0;\n    }\n  }\n\n  if (anticlockwise) {\n    var tmp = startAngle;\n    startAngle = normalizeRadian(endAngle);\n    endAngle = normalizeRadian(tmp);\n  } else {\n    startAngle = normalizeRadian(startAngle);\n    endAngle = normalizeRadian(endAngle);\n  }\n\n  if (startAngle > endAngle) {\n    endAngle += PI2;\n  }\n\n  var w = 0;\n\n  for (var i = 0; i < 2; i++) {\n    var x_ = roots[i];\n\n    if (x_ + cx > x) {\n      var angle = Math.atan2(y, x_);\n      var dir = anticlockwise ? 1 : -1;\n\n      if (angle < 0) {\n        angle = PI2 + angle;\n      }\n\n      if (angle >= startAngle && angle <= endAngle || angle + PI2 >= startAngle && angle + PI2 <= endAngle) {\n        if (angle > Math.PI / 2 && angle < Math.PI * 1.5) {\n          dir = -dir;\n        }\n\n        w += dir;\n      }\n    }\n  }\n\n  return w;\n}\n\nfunction containPath(data, lineWidth, isStroke, x, y) {\n  var w = 0;\n  var xi = 0;\n  var yi = 0;\n  var x0 = 0;\n  var y0 = 0;\n\n  for (var i = 0; i < data.length;) {\n    var cmd = data[i++]; // Begin a new subpath\n\n    if (cmd === CMD.M && i > 1) {\n      // Close previous subpath\n      if (!isStroke) {\n        w += windingLine(xi, yi, x0, y0, x, y);\n      } // 如果被任何一个 subpath 包含\n      // if (w !== 0) {\n      //     return true;\n      // }\n\n    }\n\n    if (i === 1) {\n      // 如果第一个命令是 L, C, Q\n      // 则 previous point 同绘制命令的第一个 point\n      //\n      // 第一个命令为 Arc 的情况下会在后面特殊处理\n      xi = data[i];\n      yi = data[i + 1];\n      x0 = xi;\n      y0 = yi;\n    }\n\n    switch (cmd) {\n      case CMD.M:\n        // moveTo 命令重新创建一个新的 subpath, 并且更新新的起点\n        // 在 closePath 的时候使用\n        x0 = data[i++];\n        y0 = data[i++];\n        xi = x0;\n        yi = y0;\n        break;\n\n      case CMD.L:\n        if (isStroke) {\n          if (line.containStroke(xi, yi, data[i], data[i + 1], lineWidth, x, y)) {\n            return true;\n          }\n        } else {\n          // NOTE 在第一个命令为 L, C, Q 的时候会计算出 NaN\n          w += windingLine(xi, yi, data[i], data[i + 1], x, y) || 0;\n        }\n\n        xi = data[i++];\n        yi = data[i++];\n        break;\n\n      case CMD.C:\n        if (isStroke) {\n          if (cubic.containStroke(xi, yi, data[i++], data[i++], data[i++], data[i++], data[i], data[i + 1], lineWidth, x, y)) {\n            return true;\n          }\n        } else {\n          w += windingCubic(xi, yi, data[i++], data[i++], data[i++], data[i++], data[i], data[i + 1], x, y) || 0;\n        }\n\n        xi = data[i++];\n        yi = data[i++];\n        break;\n\n      case CMD.Q:\n        if (isStroke) {\n          if (quadratic.containStroke(xi, yi, data[i++], data[i++], data[i], data[i + 1], lineWidth, x, y)) {\n            return true;\n          }\n        } else {\n          w += windingQuadratic(xi, yi, data[i++], data[i++], data[i], data[i + 1], x, y) || 0;\n        }\n\n        xi = data[i++];\n        yi = data[i++];\n        break;\n\n      case CMD.A:\n        // TODO Arc 判断的开销比较大\n        var cx = data[i++];\n        var cy = data[i++];\n        var rx = data[i++];\n        var ry = data[i++];\n        var theta = data[i++];\n        var dTheta = data[i++]; // TODO Arc 旋转\n\n        i += 1;\n        var anticlockwise = 1 - data[i++];\n        var x1 = Math.cos(theta) * rx + cx;\n        var y1 = Math.sin(theta) * ry + cy; // 不是直接使用 arc 命令\n\n        if (i > 1) {\n          w += windingLine(xi, yi, x1, y1, x, y);\n        } else {\n          // 第一个命令起点还未定义\n          x0 = x1;\n          y0 = y1;\n        } // zr 使用scale来模拟椭圆, 这里也对x做一定的缩放\n\n\n        var _x = (x - cx) * ry / rx + cx;\n\n        if (isStroke) {\n          if (arc.containStroke(cx, cy, ry, theta, theta + dTheta, anticlockwise, lineWidth, _x, y)) {\n            return true;\n          }\n        } else {\n          w += windingArc(cx, cy, ry, theta, theta + dTheta, anticlockwise, _x, y);\n        }\n\n        xi = Math.cos(theta + dTheta) * rx + cx;\n        yi = Math.sin(theta + dTheta) * ry + cy;\n        break;\n\n      case CMD.R:\n        x0 = xi = data[i++];\n        y0 = yi = data[i++];\n        var width = data[i++];\n        var height = data[i++];\n        var x1 = x0 + width;\n        var y1 = y0 + height;\n\n        if (isStroke) {\n          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)) {\n            return true;\n          }\n        } else {\n          // FIXME Clockwise ?\n          w += windingLine(x1, y0, x1, y1, x, y);\n          w += windingLine(x0, y1, x0, y0, x, y);\n        }\n\n        break;\n\n      case CMD.Z:\n        if (isStroke) {\n          if (line.containStroke(xi, yi, x0, y0, lineWidth, x, y)) {\n            return true;\n          }\n        } else {\n          // Close a subpath\n          w += windingLine(xi, yi, x0, y0, x, y); // 如果被任何一个 subpath 包含\n          // FIXME subpaths may overlap\n          // if (w !== 0) {\n          //     return true;\n          // }\n        }\n\n        xi = x0;\n        yi = y0;\n        break;\n    }\n  }\n\n  if (!isStroke && !isAroundEqual(yi, y0)) {\n    w += windingLine(xi, yi, x0, y0, x, y) || 0;\n  }\n\n  return w !== 0;\n}\n\nfunction contain(pathData, x, y) {\n  return containPath(pathData, 0, false, x, y);\n}\n\nfunction containStroke(pathData, lineWidth, x, y) {\n  return containPath(pathData, lineWidth, true, x, y);\n}\n\nexports.contain = contain;\nexports.containStroke = containStroke;","/**\n * 线段包含判断\n * @param  {number}  x0\n * @param  {number}  y0\n * @param  {number}  x1\n * @param  {number}  y1\n * @param  {number}  lineWidth\n * @param  {number}  x\n * @param  {number}  y\n * @return {boolean}\n */\nfunction containStroke(x0, y0, x1, y1, lineWidth, x, y) {\n  if (lineWidth === 0) {\n    return false;\n  }\n\n  var _l = lineWidth;\n  var _a = 0;\n  var _b = x0; // Quick reject\n\n  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) {\n    return false;\n  }\n\n  if (x0 !== x1) {\n    _a = (y0 - y1) / (x0 - x1);\n    _b = (x0 * y1 - x1 * y0) / (x0 - x1);\n  } else {\n    return Math.abs(x - x0) <= _l / 2;\n  }\n\n  var tmp = _a * x - y + _b;\n\n  var _s = tmp * tmp / (_a * _a + 1);\n\n  return _s <= _l / 2 * _l / 2;\n}\n\nexports.containStroke = containStroke;","var curve = require(\"../core/curve\");\n\n/**\n * 三次贝塞尔曲线描边包含判断\n * @param  {number}  x0\n * @param  {number}  y0\n * @param  {number}  x1\n * @param  {number}  y1\n * @param  {number}  x2\n * @param  {number}  y2\n * @param  {number}  x3\n * @param  {number}  y3\n * @param  {number}  lineWidth\n * @param  {number}  x\n * @param  {number}  y\n * @return {boolean}\n */\nfunction containStroke(x0, y0, x1, y1, x2, y2, x3, y3, lineWidth, x, y) {\n  if (lineWidth === 0) {\n    return false;\n  }\n\n  var _l = lineWidth; // Quick reject\n\n  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) {\n    return false;\n  }\n\n  var d = curve.cubicProjectPoint(x0, y0, x1, y1, x2, y2, x3, y3, x, y, null);\n  return d <= _l / 2;\n}\n\nexports.containStroke = containStroke;","var _curve = require(\"../core/curve\");\n\nvar quadraticProjectPoint = _curve.quadraticProjectPoint;\n\n/**\n * 二次贝塞尔曲线描边包含判断\n * @param  {number}  x0\n * @param  {number}  y0\n * @param  {number}  x1\n * @param  {number}  y1\n * @param  {number}  x2\n * @param  {number}  y2\n * @param  {number}  lineWidth\n * @param  {number}  x\n * @param  {number}  y\n * @return {boolean}\n */\nfunction containStroke(x0, y0, x1, y1, x2, y2, lineWidth, x, y) {\n  if (lineWidth === 0) {\n    return false;\n  }\n\n  var _l = lineWidth; // Quick reject\n\n  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) {\n    return false;\n  }\n\n  var d = quadraticProjectPoint(x0, y0, x1, y1, x2, y2, x, y, null);\n  return d <= _l / 2;\n}\n\nexports.containStroke = containStroke;","var _util = require(\"./util\");\n\nvar normalizeRadian = _util.normalizeRadian;\nvar PI2 = Math.PI * 2;\n/**\n * 圆弧描边包含判断\n * @param  {number}  cx\n * @param  {number}  cy\n * @param  {number}  r\n * @param  {number}  startAngle\n * @param  {number}  endAngle\n * @param  {boolean}  anticlockwise\n * @param  {number} lineWidth\n * @param  {number}  x\n * @param  {number}  y\n * @return {Boolean}\n */\n\nfunction containStroke(cx, cy, r, startAngle, endAngle, anticlockwise, lineWidth, x, y) {\n  if (lineWidth === 0) {\n    return false;\n  }\n\n  var _l = lineWidth;\n  x -= cx;\n  y -= cy;\n  var d = Math.sqrt(x * x + y * y);\n\n  if (d - _l > r || d + _l < r) {\n    return false;\n  }\n\n  if (Math.abs(startAngle - endAngle) % PI2 < 1e-4) {\n    // Is a circle\n    return true;\n  }\n\n  if (anticlockwise) {\n    var tmp = startAngle;\n    startAngle = normalizeRadian(endAngle);\n    endAngle = normalizeRadian(tmp);\n  } else {\n    startAngle = normalizeRadian(startAngle);\n    endAngle = normalizeRadian(endAngle);\n  }\n\n  if (startAngle > endAngle) {\n    endAngle += PI2;\n  }\n\n  var angle = Math.atan2(y, x);\n\n  if (angle < 0) {\n    angle += PI2;\n  }\n\n  return angle >= startAngle && angle <= endAngle || angle + PI2 >= startAngle && angle + PI2 <= endAngle;\n}\n\nexports.containStroke = containStroke;","function windingLine(x0, y0, x1, y1, x, y) {\n  if (y > y0 && y > y1 || y < y0 && y < y1) {\n    return 0;\n  } // Ignore horizontal line\n\n\n  if (y1 === y0) {\n    return 0;\n  }\n\n  var dir = y1 < y0 ? 1 : -1;\n  var t = (y - y0) / (y1 - y0); // Avoid winding error when intersection point is the connect point of two line of polygon\n\n  if (t === 1 || t === 0) {\n    dir = y1 < y0 ? 0.5 : -0.5;\n  }\n\n  var x_ = t * (x1 - x0) + x0; // If (x, y) on the line, considered as \"contain\".\n\n  return x_ === x ? Infinity : x_ > x ? dir : 0;\n}\n\nmodule.exports = windingLine;","var Pattern = function (image, repeat) {\n  // Should do nothing more in this constructor. Because gradient can be\n  // declard by `color: {image: ...}`, where this constructor will not be called.\n  this.image = image;\n  this.repeat = repeat; // Can be cloned\n\n  this.type = 'pattern';\n};\n\nPattern.prototype.getCanvasPattern = function (ctx) {\n  return ctx.createPattern(this.image, this.repeat || 'repeat');\n};\n\nvar _default = Pattern;\nmodule.exports = _default;","var PathProxy = require(\"../core/PathProxy\");\n\nvar _vector = require(\"../core/vector\");\n\nvar v2ApplyTransform = _vector.applyTransform;\nvar CMD = PathProxy.CMD;\nvar points = [[], [], []];\nvar mathSqrt = Math.sqrt;\nvar mathAtan2 = Math.atan2;\n\nfunction _default(path, m) {\n  var data = path.data;\n  var cmd;\n  var nPoint;\n  var i;\n  var j;\n  var k;\n  var p;\n  var M = CMD.M;\n  var C = CMD.C;\n  var L = CMD.L;\n  var R = CMD.R;\n  var A = CMD.A;\n  var Q = CMD.Q;\n\n  for (i = 0, j = 0; i < data.length;) {\n    cmd = data[i++];\n    j = i;\n    nPoint = 0;\n\n    switch (cmd) {\n      case M:\n        nPoint = 1;\n        break;\n\n      case L:\n        nPoint = 1;\n        break;\n\n      case C:\n        nPoint = 3;\n        break;\n\n      case Q:\n        nPoint = 2;\n        break;\n\n      case A:\n        var x = m[4];\n        var y = m[5];\n        var sx = mathSqrt(m[0] * m[0] + m[1] * m[1]);\n        var sy = mathSqrt(m[2] * m[2] + m[3] * m[3]);\n        var angle = mathAtan2(-m[1] / sy, m[0] / sx); // cx\n\n        data[i] *= sx;\n        data[i++] += x; // cy\n\n        data[i] *= sy;\n        data[i++] += y; // Scale rx and ry\n        // FIXME Assume psi is 0 here\n\n        data[i++] *= sx;\n        data[i++] *= sy; // Start angle\n\n        data[i++] += angle; // end angle\n\n        data[i++] += angle; // FIXME psi\n\n        i += 2;\n        j = i;\n        break;\n\n      case R:\n        // x0, y0\n        p[0] = data[i++];\n        p[1] = data[i++];\n        v2ApplyTransform(p, p, m);\n        data[j++] = p[0];\n        data[j++] = p[1]; // x1, y1\n\n        p[0] += data[i++];\n        p[1] += data[i++];\n        v2ApplyTransform(p, p, m);\n        data[j++] = p[0];\n        data[j++] = p[1];\n    }\n\n    for (k = 0; k < nPoint; k++) {\n      var p = points[k];\n      p[0] = data[i++];\n      p[1] = data[i++];\n      v2ApplyTransform(p, p, m); // Write back\n\n      data[j++] = p[0];\n      data[j++] = p[1];\n    }\n  }\n}\n\nmodule.exports = _default;","var Displayable = require(\"./Displayable\");\n\nvar BoundingRect = require(\"../core/BoundingRect\");\n\nvar zrUtil = require(\"../core/util\");\n\nvar imageHelper = require(\"./helper/image\");\n\n/**\n * @alias zrender/graphic/Image\n * @extends module:zrender/graphic/Displayable\n * @constructor\n * @param {Object} opts\n */\nfunction ZImage(opts) {\n  Displayable.call(this, opts);\n}\n\nZImage.prototype = {\n  constructor: ZImage,\n  type: 'image',\n  brush: function (ctx, prevEl) {\n    var style = this.style;\n    var src = style.image; // Must bind each time\n\n    style.bind(ctx, this, prevEl);\n    var image = this._image = imageHelper.createOrUpdateImage(src, this._image, this, this.onload);\n\n    if (!image || !imageHelper.isImageReady(image)) {\n      return;\n    } // 图片已经加载完成\n    // if (image.nodeName.toUpperCase() == 'IMG') {\n    //     if (!image.complete) {\n    //         return;\n    //     }\n    // }\n    // Else is canvas\n\n\n    var x = style.x || 0;\n    var y = style.y || 0;\n    var width = style.width;\n    var height = style.height;\n    var aspect = image.width / image.height;\n\n    if (width == null && height != null) {\n      // Keep image/height ratio\n      width = height * aspect;\n    } else if (height == null && width != null) {\n      height = width / aspect;\n    } else if (width == null && height == null) {\n      width = image.width;\n      height = image.height;\n    } // 设置transform\n\n\n    this.setTransform(ctx);\n\n    if (style.sWidth && style.sHeight) {\n      var sx = style.sx || 0;\n      var sy = style.sy || 0;\n      ctx.drawImage(image, sx, sy, style.sWidth, style.sHeight, x, y, width, height);\n    } else if (style.sx && style.sy) {\n      var sx = style.sx;\n      var sy = style.sy;\n      var sWidth = width - sx;\n      var sHeight = height - sy;\n      ctx.drawImage(image, sx, sy, sWidth, sHeight, x, y, width, height);\n    } else {\n      ctx.drawImage(image, x, y, width, height);\n    } // Draw rect text\n\n\n    if (style.text != null) {\n      // Only restore transform when needs draw text.\n      this.restoreTransform(ctx);\n      this.drawRectText(ctx, this.getBoundingRect());\n    }\n  },\n  getBoundingRect: function () {\n    var style = this.style;\n\n    if (!this._rect) {\n      this._rect = new BoundingRect(style.x || 0, style.y || 0, style.width || 0, style.height || 0);\n    }\n\n    return this._rect;\n  }\n};\nzrUtil.inherits(ZImage, Displayable);\nvar _default = ZImage;\nmodule.exports = _default;","var zrUtil = require(\"../core/util\");\n\nvar Element = require(\"../Element\");\n\nvar BoundingRect = require(\"../core/BoundingRect\");\n\n/**\n * Group是一个容器，可以插入子节点，Group的变换也会被应用到子节点上\n * @module zrender/graphic/Group\n * @example\n *     var Group = require('zrender/container/Group');\n *     var Circle = require('zrender/graphic/shape/Circle');\n *     var g = new Group();\n *     g.position[0] = 100;\n *     g.position[1] = 100;\n *     g.add(new Circle({\n *         style: {\n *             x: 100,\n *             y: 100,\n *             r: 20,\n *         }\n *     }));\n *     zr.add(g);\n */\n\n/**\n * @alias module:zrender/graphic/Group\n * @constructor\n * @extends module:zrender/mixin/Transformable\n * @extends module:zrender/mixin/Eventful\n */\nvar Group = function (opts) {\n  opts = opts || {};\n  Element.call(this, opts);\n\n  for (var key in opts) {\n    if (opts.hasOwnProperty(key)) {\n      this[key] = opts[key];\n    }\n  }\n\n  this._children = [];\n  this.__storage = null;\n  this.__dirty = true;\n};\n\nGroup.prototype = {\n  constructor: Group,\n  isGroup: true,\n\n  /**\n   * @type {string}\n   */\n  type: 'group',\n\n  /**\n   * 所有子孙元素是否响应鼠标事件\n   * @name module:/zrender/container/Group#silent\n   * @type {boolean}\n   * @default false\n   */\n  silent: false,\n\n  /**\n   * @return {Array.<module:zrender/Element>}\n   */\n  children: function () {\n    return this._children.slice();\n  },\n\n  /**\n   * 获取指定 index 的儿子节点\n   * @param  {number} idx\n   * @return {module:zrender/Element}\n   */\n  childAt: function (idx) {\n    return this._children[idx];\n  },\n\n  /**\n   * 获取指定名字的儿子节点\n   * @param  {string} name\n   * @return {module:zrender/Element}\n   */\n  childOfName: function (name) {\n    var children = this._children;\n\n    for (var i = 0; i < children.length; i++) {\n      if (children[i].name === name) {\n        return children[i];\n      }\n    }\n  },\n\n  /**\n   * @return {number}\n   */\n  childCount: function () {\n    return this._children.length;\n  },\n\n  /**\n   * 添加子节点到最后\n   * @param {module:zrender/Element} child\n   */\n  add: function (child) {\n    if (child && child !== this && child.parent !== this) {\n      this._children.push(child);\n\n      this._doAdd(child);\n    }\n\n    return this;\n  },\n\n  /**\n   * 添加子节点在 nextSibling 之前\n   * @param {module:zrender/Element} child\n   * @param {module:zrender/Element} nextSibling\n   */\n  addBefore: function (child, nextSibling) {\n    if (child && child !== this && child.parent !== this && nextSibling && nextSibling.parent === this) {\n      var children = this._children;\n      var idx = children.indexOf(nextSibling);\n\n      if (idx >= 0) {\n        children.splice(idx, 0, child);\n\n        this._doAdd(child);\n      }\n    }\n\n    return this;\n  },\n  _doAdd: function (child) {\n    if (child.parent) {\n      child.parent.remove(child);\n    }\n\n    child.parent = this;\n    var storage = this.__storage;\n    var zr = this.__zr;\n\n    if (storage && storage !== child.__storage) {\n      storage.addToStorage(child);\n\n      if (child instanceof Group) {\n        child.addChildrenToStorage(storage);\n      }\n    }\n\n    zr && zr.refresh();\n  },\n\n  /**\n   * 移除子节点\n   * @param {module:zrender/Element} child\n   */\n  remove: function (child) {\n    var zr = this.__zr;\n    var storage = this.__storage;\n    var children = this._children;\n    var idx = zrUtil.indexOf(children, child);\n\n    if (idx < 0) {\n      return this;\n    }\n\n    children.splice(idx, 1);\n    child.parent = null;\n\n    if (storage) {\n      storage.delFromStorage(child);\n\n      if (child instanceof Group) {\n        child.delChildrenFromStorage(storage);\n      }\n    }\n\n    zr && zr.refresh();\n    return this;\n  },\n\n  /**\n   * 移除所有子节点\n   */\n  removeAll: function () {\n    var children = this._children;\n    var storage = this.__storage;\n    var child;\n    var i;\n\n    for (i = 0; i < children.length; i++) {\n      child = children[i];\n\n      if (storage) {\n        storage.delFromStorage(child);\n\n        if (child instanceof Group) {\n          child.delChildrenFromStorage(storage);\n        }\n      }\n\n      child.parent = null;\n    }\n\n    children.length = 0;\n    return this;\n  },\n\n  /**\n   * 遍历所有子节点\n   * @param  {Function} cb\n   * @param  {}   context\n   */\n  eachChild: function (cb, context) {\n    var children = this._children;\n\n    for (var i = 0; i < children.length; i++) {\n      var child = children[i];\n      cb.call(context, child, i);\n    }\n\n    return this;\n  },\n\n  /**\n   * 深度优先遍历所有子孙节点\n   * @param  {Function} cb\n   * @param  {}   context\n   */\n  traverse: function (cb, context) {\n    for (var i = 0; i < this._children.length; i++) {\n      var child = this._children[i];\n      cb.call(context, child);\n\n      if (child.type === 'group') {\n        child.traverse(cb, context);\n      }\n    }\n\n    return this;\n  },\n  addChildrenToStorage: function (storage) {\n    for (var i = 0; i < this._children.length; i++) {\n      var child = this._children[i];\n      storage.addToStorage(child);\n\n      if (child instanceof Group) {\n        child.addChildrenToStorage(storage);\n      }\n    }\n  },\n  delChildrenFromStorage: function (storage) {\n    for (var i = 0; i < this._children.length; i++) {\n      var child = this._children[i];\n      storage.delFromStorage(child);\n\n      if (child instanceof Group) {\n        child.delChildrenFromStorage(storage);\n      }\n    }\n  },\n  dirty: function () {\n    this.__dirty = true;\n    this.__zr && this.__zr.refresh();\n    return this;\n  },\n\n  /**\n   * @return {module:zrender/core/BoundingRect}\n   */\n  getBoundingRect: function (includeChildren) {\n    // TODO Caching\n    var rect = null;\n    var tmpRect = new BoundingRect(0, 0, 0, 0);\n    var children = includeChildren || this._children;\n    var tmpMat = [];\n\n    for (var i = 0; i < children.length; i++) {\n      var child = children[i];\n\n      if (child.ignore || child.invisible) {\n        continue;\n      }\n\n      var childRect = child.getBoundingRect();\n      var transform = child.getLocalTransform(tmpMat); // TODO\n      // The boundingRect cacluated by transforming original\n      // rect may be bigger than the actual bundingRect when rotation\n      // is used. (Consider a circle rotated aginst its center, where\n      // the actual boundingRect should be the same as that not be\n      // rotated.) But we can not find better approach to calculate\n      // actual boundingRect yet, considering performance.\n\n      if (transform) {\n        tmpRect.copy(childRect);\n        tmpRect.applyTransform(transform);\n        rect = rect || tmpRect.clone();\n        rect.union(tmpRect);\n      } else {\n        rect = rect || childRect.clone();\n        rect.union(childRect);\n      }\n    }\n\n    return rect || tmpRect;\n  }\n};\nzrUtil.inherits(Group, Element);\nvar _default = Group;\nmodule.exports = _default;","var Displayable = require(\"./Displayable\");\n\nvar zrUtil = require(\"../core/util\");\n\nvar textContain = require(\"../contain/text\");\n\nvar textHelper = require(\"./helper/text\");\n\nvar _constant = require(\"./constant\");\n\nvar ContextCachedBy = _constant.ContextCachedBy;\n\n/**\n * @alias zrender/graphic/Text\n * @extends module:zrender/graphic/Displayable\n * @constructor\n * @param {Object} opts\n */\nvar Text = function (opts) {\n  // jshint ignore:line\n  Displayable.call(this, opts);\n};\n\nText.prototype = {\n  constructor: Text,\n  type: 'text',\n  brush: function (ctx, prevEl) {\n    var style = this.style; // Optimize, avoid normalize every time.\n\n    this.__dirty && textHelper.normalizeTextStyle(style, true); // Use props with prefix 'text'.\n\n    style.fill = style.stroke = style.shadowBlur = style.shadowColor = style.shadowOffsetX = style.shadowOffsetY = null;\n    var text = style.text; // Convert to string\n\n    text != null && (text += ''); // Do not apply style.bind in Text node. Because the real bind job\n    // is in textHelper.renderText, and performance of text render should\n    // be considered.\n    // style.bind(ctx, this, prevEl);\n\n    if (!textHelper.needDrawText(text, style)) {\n      // The current el.style is not applied\n      // and should not be used as cache.\n      ctx.__attrCachedBy = ContextCachedBy.NONE;\n      return;\n    }\n\n    this.setTransform(ctx);\n    textHelper.renderText(this, ctx, text, style, null, prevEl);\n    this.restoreTransform(ctx);\n  },\n  getBoundingRect: function () {\n    var style = this.style; // Optimize, avoid normalize every time.\n\n    this.__dirty && textHelper.normalizeTextStyle(style, true);\n\n    if (!this._rect) {\n      var text = style.text;\n      text != null ? text += '' : text = '';\n      var rect = textContain.getBoundingRect(style.text + '', style.font, style.textAlign, style.textVerticalAlign, style.textPadding, style.textLineHeight, style.rich);\n      rect.x += style.x || 0;\n      rect.y += style.y || 0;\n\n      if (textHelper.getStroke(style.textStroke, style.textStrokeWidth)) {\n        var w = style.textStrokeWidth;\n        rect.x -= w / 2;\n        rect.y -= w / 2;\n        rect.width += w;\n        rect.height += w;\n      }\n\n      this._rect = rect;\n    }\n\n    return this._rect;\n  }\n};\nzrUtil.inherits(Text, Displayable);\nvar _default = Text;\nmodule.exports = _default;","var Path = require(\"../Path\");\n\n/**\n * 圆形\n * @module zrender/shape/Circle\n */\nvar _default = Path.extend({\n  type: 'circle',\n  shape: {\n    cx: 0,\n    cy: 0,\n    r: 0\n  },\n  buildPath: function (ctx, shape, inBundle) {\n    // Better stroking in ShapeBundle\n    // Always do it may have performence issue ( fill may be 2x more cost)\n    if (inBundle) {\n      ctx.moveTo(shape.cx + shape.r, shape.cy);\n    } // else {\n    //     if (ctx.allocate && !ctx.data.length) {\n    //         ctx.allocate(ctx.CMD_MEM_SIZE.A);\n    //     }\n    // }\n    // Better stroking in ShapeBundle\n    // ctx.moveTo(shape.cx + shape.r, shape.cy);\n\n\n    ctx.arc(shape.cx, shape.cy, shape.r, 0, Math.PI * 2, true);\n  }\n});\n\nmodule.exports = _default;","var Path = require(\"../Path\");\n\nvar fixClipWithShadow = require(\"../helper/fixClipWithShadow\");\n\n/**\n * 扇形\n * @module zrender/graphic/shape/Sector\n */\nvar _default = Path.extend({\n  type: 'sector',\n  shape: {\n    cx: 0,\n    cy: 0,\n    r0: 0,\n    r: 0,\n    startAngle: 0,\n    endAngle: Math.PI * 2,\n    clockwise: true\n  },\n  brush: fixClipWithShadow(Path.prototype.brush),\n  buildPath: function (ctx, shape) {\n    var x = shape.cx;\n    var y = shape.cy;\n    var r0 = Math.max(shape.r0 || 0, 0);\n    var r = Math.max(shape.r, 0);\n    var startAngle = shape.startAngle;\n    var endAngle = shape.endAngle;\n    var clockwise = shape.clockwise;\n    var unitX = Math.cos(startAngle);\n    var unitY = Math.sin(startAngle);\n    ctx.moveTo(unitX * r0 + x, unitY * r0 + y);\n    ctx.lineTo(unitX * r + x, unitY * r + y);\n    ctx.arc(x, y, r, startAngle, endAngle, !clockwise);\n    ctx.lineTo(Math.cos(endAngle) * r0 + x, Math.sin(endAngle) * r0 + y);\n\n    if (r0 !== 0) {\n      ctx.arc(x, y, r0, endAngle, startAngle, clockwise);\n    }\n\n    ctx.closePath();\n  }\n});\n\nmodule.exports = _default;","var env = require(\"../../core/env\");\n\n// Fix weird bug in some version of IE11 (like 11.0.9600.178**),\n// where exception \"unexpected call to method or property access\"\n// might be thrown when calling ctx.fill or ctx.stroke after a path\n// whose area size is zero is drawn and ctx.clip() is called and\n// shadowBlur is set. See #4572, #3112, #5777.\n// (e.g.,\n//  ctx.moveTo(10, 10);\n//  ctx.lineTo(20, 10);\n//  ctx.closePath();\n//  ctx.clip();\n//  ctx.shadowBlur = 10;\n//  ...\n//  ctx.fill();\n// )\nvar shadowTemp = [['shadowBlur', 0], ['shadowColor', '#000'], ['shadowOffsetX', 0], ['shadowOffsetY', 0]];\n\nfunction _default(orignalBrush) {\n  // version string can be: '11.0'\n  return env.browser.ie && env.browser.version >= 11 ? function () {\n    var clipPaths = this.__clipPaths;\n    var style = this.style;\n    var modified;\n\n    if (clipPaths) {\n      for (var i = 0; i < clipPaths.length; i++) {\n        var clipPath = clipPaths[i];\n        var shape = clipPath && clipPath.shape;\n        var type = clipPath && clipPath.type;\n\n        if (shape && (type === 'sector' && shape.startAngle === shape.endAngle || type === 'rect' && (!shape.width || !shape.height))) {\n          for (var j = 0; j < shadowTemp.length; j++) {\n            // It is save to put shadowTemp static, because shadowTemp\n            // will be all modified each item brush called.\n            shadowTemp[j][2] = style[shadowTemp[j][0]];\n            style[shadowTemp[j][0]] = shadowTemp[j][1];\n          }\n\n          modified = true;\n          break;\n        }\n      }\n    }\n\n    orignalBrush.apply(this, arguments);\n\n    if (modified) {\n      for (var j = 0; j < shadowTemp.length; j++) {\n        style[shadowTemp[j][0]] = shadowTemp[j][2];\n      }\n    }\n  } : orignalBrush;\n}\n\nmodule.exports = _default;","var Path = require(\"../Path\");\n\n/**\n * 圆环\n * @module zrender/graphic/shape/Ring\n */\nvar _default = Path.extend({\n  type: 'ring',\n  shape: {\n    cx: 0,\n    cy: 0,\n    r: 0,\n    r0: 0\n  },\n  buildPath: function (ctx, shape) {\n    var x = shape.cx;\n    var y = shape.cy;\n    var PI2 = Math.PI * 2;\n    ctx.moveTo(x + shape.r, y);\n    ctx.arc(x, y, shape.r, 0, PI2, false);\n    ctx.moveTo(x + shape.r0, y);\n    ctx.arc(x, y, shape.r0, 0, PI2, true);\n  }\n});\n\nmodule.exports = _default;","var Path = require(\"../Path\");\n\nvar polyHelper = require(\"../helper/poly\");\n\n/**\n * 多边形\n * @module zrender/shape/Polygon\n */\nvar _default = Path.extend({\n  type: 'polygon',\n  shape: {\n    points: null,\n    smooth: false,\n    smoothConstraint: null\n  },\n  buildPath: function (ctx, shape) {\n    polyHelper.buildPath(ctx, shape, true);\n  }\n});\n\nmodule.exports = _default;","var _vector = require(\"../../core/vector\");\n\nvar v2Distance = _vector.distance;\n\n/**\n * Catmull-Rom spline 插值折线\n * @module zrender/shape/util/smoothSpline\n * @author pissang (https://www.github.com/pissang)\n *         Kener (@Kener-林峰, kener.linfeng@gmail.com)\n *         errorrik (errorrik@gmail.com)\n */\n\n/**\n * @inner\n */\nfunction interpolate(p0, p1, p2, p3, t, t2, t3) {\n  var v0 = (p2 - p0) * 0.5;\n  var v1 = (p3 - p1) * 0.5;\n  return (2 * (p1 - p2) + v0 + v1) * t3 + (-3 * (p1 - p2) - 2 * v0 - v1) * t2 + v0 * t + p1;\n}\n/**\n * @alias module:zrender/shape/util/smoothSpline\n * @param {Array} points 线段顶点数组\n * @param {boolean} isLoop\n * @return {Array}\n */\n\n\nfunction _default(points, isLoop) {\n  var len = points.length;\n  var ret = [];\n  var distance = 0;\n\n  for (var i = 1; i < len; i++) {\n    distance += v2Distance(points[i - 1], points[i]);\n  }\n\n  var segs = distance / 2;\n  segs = segs < len ? len : segs;\n\n  for (var i = 0; i < segs; i++) {\n    var pos = i / (segs - 1) * (isLoop ? len : len - 1);\n    var idx = Math.floor(pos);\n    var w = pos - idx;\n    var p0;\n    var p1 = points[idx % len];\n    var p2;\n    var p3;\n\n    if (!isLoop) {\n      p0 = points[idx === 0 ? idx : idx - 1];\n      p2 = points[idx > len - 2 ? len - 1 : idx + 1];\n      p3 = points[idx > len - 3 ? len - 1 : idx + 2];\n    } else {\n      p0 = points[(idx - 1 + len) % len];\n      p2 = points[(idx + 1) % len];\n      p3 = points[(idx + 2) % len];\n    }\n\n    var w2 = w * w;\n    var w3 = w * w2;\n    ret.push([interpolate(p0[0], p1[0], p2[0], p3[0], w, w2, w3), interpolate(p0[1], p1[1], p2[1], p3[1], w, w2, w3)]);\n  }\n\n  return ret;\n}\n\nmodule.exports = _default;","var _vector = require(\"../../core/vector\");\n\nvar v2Min = _vector.min;\nvar v2Max = _vector.max;\nvar v2Scale = _vector.scale;\nvar v2Distance = _vector.distance;\nvar v2Add = _vector.add;\nvar v2Clone = _vector.clone;\nvar v2Sub = _vector.sub;\n\n/**\n * 贝塞尔平滑曲线\n * @module zrender/shape/util/smoothBezier\n * @author pissang (https://www.github.com/pissang)\n *         Kener (@Kener-林峰, kener.linfeng@gmail.com)\n *         errorrik (errorrik@gmail.com)\n */\n\n/**\n * 贝塞尔平滑曲线\n * @alias module:zrender/shape/util/smoothBezier\n * @param {Array} points 线段顶点数组\n * @param {number} smooth 平滑等级, 0-1\n * @param {boolean} isLoop\n * @param {Array} constraint 将计算出来的控制点约束在一个包围盒内\n *                           比如 [[0, 0], [100, 100]], 这个包围盒会与\n *                           整个折线的包围盒做一个并集用来约束控制点。\n * @param {Array} 计算出来的控制点数组\n */\nfunction _default(points, smooth, isLoop, constraint) {\n  var cps = [];\n  var v = [];\n  var v1 = [];\n  var v2 = [];\n  var prevPoint;\n  var nextPoint;\n  var min;\n  var max;\n\n  if (constraint) {\n    min = [Infinity, Infinity];\n    max = [-Infinity, -Infinity];\n\n    for (var i = 0, len = points.length; i < len; i++) {\n      v2Min(min, min, points[i]);\n      v2Max(max, max, points[i]);\n    } // 与指定的包围盒做并集\n\n\n    v2Min(min, min, constraint[0]);\n    v2Max(max, max, constraint[1]);\n  }\n\n  for (var i = 0, len = points.length; i < len; i++) {\n    var point = points[i];\n\n    if (isLoop) {\n      prevPoint = points[i ? i - 1 : len - 1];\n      nextPoint = points[(i + 1) % len];\n    } else {\n      if (i === 0 || i === len - 1) {\n        cps.push(v2Clone(points[i]));\n        continue;\n      } else {\n        prevPoint = points[i - 1];\n        nextPoint = points[i + 1];\n      }\n    }\n\n    v2Sub(v, nextPoint, prevPoint); // use degree to scale the handle length\n\n    v2Scale(v, v, smooth);\n    var d0 = v2Distance(point, prevPoint);\n    var d1 = v2Distance(point, nextPoint);\n    var sum = d0 + d1;\n\n    if (sum !== 0) {\n      d0 /= sum;\n      d1 /= sum;\n    }\n\n    v2Scale(v1, v, -d0);\n    v2Scale(v2, v, d1);\n    var cp0 = v2Add([], point, v1);\n    var cp1 = v2Add([], point, v2);\n\n    if (constraint) {\n      v2Max(cp0, cp0, min);\n      v2Min(cp0, cp0, max);\n      v2Max(cp1, cp1, min);\n      v2Min(cp1, cp1, max);\n    }\n\n    cps.push(cp0);\n    cps.push(cp1);\n  }\n\n  if (isLoop) {\n    cps.push(cps.shift());\n  }\n\n  return cps;\n}\n\nmodule.exports = _default;","var Path = require(\"../Path\");\n\nvar polyHelper = require(\"../helper/poly\");\n\n/**\n * @module zrender/graphic/shape/Polyline\n */\nvar _default = Path.extend({\n  type: 'polyline',\n  shape: {\n    points: null,\n    smooth: false,\n    smoothConstraint: null\n  },\n  style: {\n    stroke: '#000',\n    fill: null\n  },\n  buildPath: function (ctx, shape) {\n    polyHelper.buildPath(ctx, shape, false);\n  }\n});\n\nmodule.exports = _default;","var Path = require(\"../Path\");\n\nvar roundRectHelper = require(\"../helper/roundRect\");\n\nvar _subPixelOptimize = require(\"../helper/subPixelOptimize\");\n\nvar subPixelOptimizeRect = _subPixelOptimize.subPixelOptimizeRect;\n\n/**\n * 矩形\n * @module zrender/graphic/shape/Rect\n */\n// Avoid create repeatly.\nvar subPixelOptimizeOutputShape = {};\n\nvar _default = Path.extend({\n  type: 'rect',\n  shape: {\n    // 左上、右上、右下、左下角的半径依次为r1、r2、r3、r4\n    // r缩写为1         相当于 [1, 1, 1, 1]\n    // r缩写为[1]       相当于 [1, 1, 1, 1]\n    // r缩写为[1, 2]    相当于 [1, 2, 1, 2]\n    // r缩写为[1, 2, 3] 相当于 [1, 2, 3, 2]\n    r: 0,\n    x: 0,\n    y: 0,\n    width: 0,\n    height: 0\n  },\n  buildPath: function (ctx, shape) {\n    var x;\n    var y;\n    var width;\n    var height;\n\n    if (this.subPixelOptimize) {\n      subPixelOptimizeRect(subPixelOptimizeOutputShape, shape, this.style);\n      x = subPixelOptimizeOutputShape.x;\n      y = subPixelOptimizeOutputShape.y;\n      width = subPixelOptimizeOutputShape.width;\n      height = subPixelOptimizeOutputShape.height;\n      subPixelOptimizeOutputShape.r = shape.r;\n      shape = subPixelOptimizeOutputShape;\n    } else {\n      x = shape.x;\n      y = shape.y;\n      width = shape.width;\n      height = shape.height;\n    }\n\n    if (!shape.r) {\n      ctx.rect(x, y, width, height);\n    } else {\n      roundRectHelper.buildPath(ctx, shape);\n    }\n\n    ctx.closePath();\n    return;\n  }\n});\n\nmodule.exports = _default;","var Path = require(\"../Path\");\n\nvar _subPixelOptimize = require(\"../helper/subPixelOptimize\");\n\nvar subPixelOptimizeLine = _subPixelOptimize.subPixelOptimizeLine;\n\n/**\n * 直线\n * @module zrender/graphic/shape/Line\n */\n// Avoid create repeatly.\nvar subPixelOptimizeOutputShape = {};\n\nvar _default = Path.extend({\n  type: 'line',\n  shape: {\n    // Start point\n    x1: 0,\n    y1: 0,\n    // End point\n    x2: 0,\n    y2: 0,\n    percent: 1\n  },\n  style: {\n    stroke: '#000',\n    fill: null\n  },\n  buildPath: function (ctx, shape) {\n    var x1;\n    var y1;\n    var x2;\n    var y2;\n\n    if (this.subPixelOptimize) {\n      subPixelOptimizeLine(subPixelOptimizeOutputShape, shape, this.style);\n      x1 = subPixelOptimizeOutputShape.x1;\n      y1 = subPixelOptimizeOutputShape.y1;\n      x2 = subPixelOptimizeOutputShape.x2;\n      y2 = subPixelOptimizeOutputShape.y2;\n    } else {\n      x1 = shape.x1;\n      y1 = shape.y1;\n      x2 = shape.x2;\n      y2 = shape.y2;\n    }\n\n    var percent = shape.percent;\n\n    if (percent === 0) {\n      return;\n    }\n\n    ctx.moveTo(x1, y1);\n\n    if (percent < 1) {\n      x2 = x1 * (1 - percent) + x2 * percent;\n      y2 = y1 * (1 - percent) + y2 * percent;\n    }\n\n    ctx.lineTo(x2, y2);\n  },\n\n  /**\n   * Get point at percent\n   * @param  {number} percent\n   * @return {Array.<number>}\n   */\n  pointAt: function (p) {\n    var shape = this.shape;\n    return [shape.x1 * (1 - p) + shape.x2 * p, shape.y1 * (1 - p) + shape.y2 * p];\n  }\n});\n\nmodule.exports = _default;","var Path = require(\"../Path\");\n\nvar vec2 = require(\"../../core/vector\");\n\nvar _curve = require(\"../../core/curve\");\n\nvar quadraticSubdivide = _curve.quadraticSubdivide;\nvar cubicSubdivide = _curve.cubicSubdivide;\nvar quadraticAt = _curve.quadraticAt;\nvar cubicAt = _curve.cubicAt;\nvar quadraticDerivativeAt = _curve.quadraticDerivativeAt;\nvar cubicDerivativeAt = _curve.cubicDerivativeAt;\n\n/**\n * 贝塞尔曲线\n * @module zrender/shape/BezierCurve\n */\nvar out = [];\n\nfunction someVectorAt(shape, t, isTangent) {\n  var cpx2 = shape.cpx2;\n  var cpy2 = shape.cpy2;\n\n  if (cpx2 === null || cpy2 === null) {\n    return [(isTangent ? cubicDerivativeAt : cubicAt)(shape.x1, shape.cpx1, shape.cpx2, shape.x2, t), (isTangent ? cubicDerivativeAt : cubicAt)(shape.y1, shape.cpy1, shape.cpy2, shape.y2, t)];\n  } else {\n    return [(isTangent ? quadraticDerivativeAt : quadraticAt)(shape.x1, shape.cpx1, shape.x2, t), (isTangent ? quadraticDerivativeAt : quadraticAt)(shape.y1, shape.cpy1, shape.y2, t)];\n  }\n}\n\nvar _default = Path.extend({\n  type: 'bezier-curve',\n  shape: {\n    x1: 0,\n    y1: 0,\n    x2: 0,\n    y2: 0,\n    cpx1: 0,\n    cpy1: 0,\n    // cpx2: 0,\n    // cpy2: 0\n    // Curve show percent, for animating\n    percent: 1\n  },\n  style: {\n    stroke: '#000',\n    fill: null\n  },\n  buildPath: function (ctx, shape) {\n    var x1 = shape.x1;\n    var y1 = shape.y1;\n    var x2 = shape.x2;\n    var y2 = shape.y2;\n    var cpx1 = shape.cpx1;\n    var cpy1 = shape.cpy1;\n    var cpx2 = shape.cpx2;\n    var cpy2 = shape.cpy2;\n    var percent = shape.percent;\n\n    if (percent === 0) {\n      return;\n    }\n\n    ctx.moveTo(x1, y1);\n\n    if (cpx2 == null || cpy2 == null) {\n      if (percent < 1) {\n        quadraticSubdivide(x1, cpx1, x2, percent, out);\n        cpx1 = out[1];\n        x2 = out[2];\n        quadraticSubdivide(y1, cpy1, y2, percent, out);\n        cpy1 = out[1];\n        y2 = out[2];\n      }\n\n      ctx.quadraticCurveTo(cpx1, cpy1, x2, y2);\n    } else {\n      if (percent < 1) {\n        cubicSubdivide(x1, cpx1, cpx2, x2, percent, out);\n        cpx1 = out[1];\n        cpx2 = out[2];\n        x2 = out[3];\n        cubicSubdivide(y1, cpy1, cpy2, y2, percent, out);\n        cpy1 = out[1];\n        cpy2 = out[2];\n        y2 = out[3];\n      }\n\n      ctx.bezierCurveTo(cpx1, cpy1, cpx2, cpy2, x2, y2);\n    }\n  },\n\n  /**\n   * Get point at percent\n   * @param  {number} t\n   * @return {Array.<number>}\n   */\n  pointAt: function (t) {\n    return someVectorAt(this.shape, t, false);\n  },\n\n  /**\n   * Get tangent at percent\n   * @param  {number} t\n   * @return {Array.<number>}\n   */\n  tangentAt: function (t) {\n    var p = someVectorAt(this.shape, t, true);\n    return vec2.normalize(p, p);\n  }\n});\n\nmodule.exports = _default;","var Path = require(\"../Path\");\n\n/**\n * 圆弧\n * @module zrender/graphic/shape/Arc\n */\nvar _default = Path.extend({\n  type: 'arc',\n  shape: {\n    cx: 0,\n    cy: 0,\n    r: 0,\n    startAngle: 0,\n    endAngle: Math.PI * 2,\n    clockwise: true\n  },\n  style: {\n    stroke: '#000',\n    fill: null\n  },\n  buildPath: function (ctx, shape) {\n    var x = shape.cx;\n    var y = shape.cy;\n    var r = Math.max(shape.r, 0);\n    var startAngle = shape.startAngle;\n    var endAngle = shape.endAngle;\n    var clockwise = shape.clockwise;\n    var unitX = Math.cos(startAngle);\n    var unitY = Math.sin(startAngle);\n    ctx.moveTo(unitX * r + x, unitY * r + y);\n    ctx.arc(x, y, r, startAngle, endAngle, !clockwise);\n  }\n});\n\nmodule.exports = _default;","var Path = require(\"./Path\");\n\n// CompoundPath to improve performance\nvar _default = Path.extend({\n  type: 'compound',\n  shape: {\n    paths: null\n  },\n  _updatePathDirty: function () {\n    var dirtyPath = this.__dirtyPath;\n    var paths = this.shape.paths;\n\n    for (var i = 0; i < paths.length; i++) {\n      // Mark as dirty if any subpath is dirty\n      dirtyPath = dirtyPath || paths[i].__dirtyPath;\n    }\n\n    this.__dirtyPath = dirtyPath;\n    this.__dirty = this.__dirty || dirtyPath;\n  },\n  beforeBrush: function () {\n    this._updatePathDirty();\n\n    var paths = this.shape.paths || [];\n    var scale = this.getGlobalScale(); // Update path scale\n\n    for (var i = 0; i < paths.length; i++) {\n      if (!paths[i].path) {\n        paths[i].createPathProxy();\n      }\n\n      paths[i].path.setScale(scale[0], scale[1]);\n    }\n  },\n  buildPath: function (ctx, shape) {\n    var paths = shape.paths || [];\n\n    for (var i = 0; i < paths.length; i++) {\n      paths[i].buildPath(ctx, paths[i].shape, true);\n    }\n  },\n  afterBrush: function () {\n    var paths = this.shape.paths || [];\n\n    for (var i = 0; i < paths.length; i++) {\n      paths[i].__dirtyPath = false;\n    }\n  },\n  getBoundingRect: function () {\n    this._updatePathDirty();\n\n    return Path.prototype.getBoundingRect.call(this);\n  }\n});\n\nmodule.exports = _default;","var zrUtil = require(\"../core/util\");\n\nvar Gradient = require(\"./Gradient\");\n\n/**\n * x, y, x2, y2 are all percent from 0 to 1\n * @param {number} [x=0]\n * @param {number} [y=0]\n * @param {number} [x2=1]\n * @param {number} [y2=0]\n * @param {Array.<Object>} colorStops\n * @param {boolean} [globalCoord=false]\n */\nvar LinearGradient = function (x, y, x2, y2, colorStops, globalCoord) {\n  // Should do nothing more in this constructor. Because gradient can be\n  // declard by `color: {type: 'linear', colorStops: ...}`, where\n  // this constructor will not be called.\n  this.x = x == null ? 0 : x;\n  this.y = y == null ? 0 : y;\n  this.x2 = x2 == null ? 1 : x2;\n  this.y2 = y2 == null ? 0 : y2; // Can be cloned\n\n  this.type = 'linear'; // If use global coord\n\n  this.global = globalCoord || false;\n  Gradient.call(this, colorStops);\n};\n\nLinearGradient.prototype = {\n  constructor: LinearGradient\n};\nzrUtil.inherits(LinearGradient, Gradient);\nvar _default = LinearGradient;\nmodule.exports = _default;","var zrUtil = require(\"../core/util\");\n\nvar Gradient = require(\"./Gradient\");\n\n/**\n * x, y, r are all percent from 0 to 1\n * @param {number} [x=0.5]\n * @param {number} [y=0.5]\n * @param {number} [r=0.5]\n * @param {Array.<Object>} [colorStops]\n * @param {boolean} [globalCoord=false]\n */\nvar RadialGradient = function (x, y, r, colorStops, globalCoord) {\n  // Should do nothing more in this constructor. Because gradient can be\n  // declard by `color: {type: 'radial', colorStops: ...}`, where\n  // this constructor will not be called.\n  this.x = x == null ? 0.5 : x;\n  this.y = y == null ? 0.5 : y;\n  this.r = r == null ? 0.5 : r; // Can be cloned\n\n  this.type = 'radial'; // If use global coord\n\n  this.global = globalCoord || false;\n  Gradient.call(this, colorStops);\n};\n\nRadialGradient.prototype = {\n  constructor: RadialGradient\n};\nzrUtil.inherits(RadialGradient, Gradient);\nvar _default = RadialGradient;\nmodule.exports = _default;","var _util = require(\"../core/util\");\n\nvar inherits = _util.inherits;\n\nvar Displayble = require(\"./Displayable\");\n\nvar BoundingRect = require(\"../core/BoundingRect\");\n\n/**\n * Displayable for incremental rendering. It will be rendered in a separate layer\n * IncrementalDisplay have two main methods. `clearDisplayables` and `addDisplayables`\n * addDisplayables will render the added displayables incremetally.\n *\n * It use a not clearFlag to tell the painter don't clear the layer if it's the first element.\n */\n// TODO Style override ?\nfunction IncrementalDisplayble(opts) {\n  Displayble.call(this, opts);\n  this._displayables = [];\n  this._temporaryDisplayables = [];\n  this._cursor = 0;\n  this.notClear = true;\n}\n\nIncrementalDisplayble.prototype.incremental = true;\n\nIncrementalDisplayble.prototype.clearDisplaybles = function () {\n  this._displayables = [];\n  this._temporaryDisplayables = [];\n  this._cursor = 0;\n  this.dirty();\n  this.notClear = false;\n};\n\nIncrementalDisplayble.prototype.addDisplayable = function (displayable, notPersistent) {\n  if (notPersistent) {\n    this._temporaryDisplayables.push(displayable);\n  } else {\n    this._displayables.push(displayable);\n  }\n\n  this.dirty();\n};\n\nIncrementalDisplayble.prototype.addDisplayables = function (displayables, notPersistent) {\n  notPersistent = notPersistent || false;\n\n  for (var i = 0; i < displayables.length; i++) {\n    this.addDisplayable(displayables[i], notPersistent);\n  }\n};\n\nIncrementalDisplayble.prototype.eachPendingDisplayable = function (cb) {\n  for (var i = this._cursor; i < this._displayables.length; i++) {\n    cb && cb(this._displayables[i]);\n  }\n\n  for (var i = 0; i < this._temporaryDisplayables.length; i++) {\n    cb && cb(this._temporaryDisplayables[i]);\n  }\n};\n\nIncrementalDisplayble.prototype.update = function () {\n  this.updateTransform();\n\n  for (var i = this._cursor; i < this._displayables.length; i++) {\n    var displayable = this._displayables[i]; // PENDING\n\n    displayable.parent = this;\n    displayable.update();\n    displayable.parent = null;\n  }\n\n  for (var i = 0; i < this._temporaryDisplayables.length; i++) {\n    var displayable = this._temporaryDisplayables[i]; // PENDING\n\n    displayable.parent = this;\n    displayable.update();\n    displayable.parent = null;\n  }\n};\n\nIncrementalDisplayble.prototype.brush = function (ctx, prevEl) {\n  // Render persistant displayables.\n  for (var i = this._cursor; i < this._displayables.length; i++) {\n    var displayable = this._displayables[i];\n    displayable.beforeBrush && displayable.beforeBrush(ctx);\n    displayable.brush(ctx, i === this._cursor ? null : this._displayables[i - 1]);\n    displayable.afterBrush && displayable.afterBrush(ctx);\n  }\n\n  this._cursor = i; // Render temporary displayables.\n\n  for (var i = 0; i < this._temporaryDisplayables.length; i++) {\n    var displayable = this._temporaryDisplayables[i];\n    displayable.beforeBrush && displayable.beforeBrush(ctx);\n    displayable.brush(ctx, i === 0 ? null : this._temporaryDisplayables[i - 1]);\n    displayable.afterBrush && displayable.afterBrush(ctx);\n  }\n\n  this._temporaryDisplayables = [];\n  this.notClear = true;\n};\n\nvar m = [];\n\nIncrementalDisplayble.prototype.getBoundingRect = function () {\n  if (!this._rect) {\n    var rect = new BoundingRect(Infinity, Infinity, -Infinity, -Infinity);\n\n    for (var i = 0; i < this._displayables.length; i++) {\n      var displayable = this._displayables[i];\n      var childRect = displayable.getBoundingRect().clone();\n\n      if (displayable.needLocalTransform()) {\n        childRect.applyTransform(displayable.getLocalTransform(m));\n      }\n\n      rect.union(childRect);\n    }\n\n    this._rect = rect;\n  }\n\n  return this._rect;\n};\n\nIncrementalDisplayble.prototype.contain = function (x, y) {\n  var localPos = this.transformCoordToLocal(x, y);\n  var rect = this.getBoundingRect();\n\n  if (rect.contain(localPos[0], localPos[1])) {\n    for (var i = 0; i < this._displayables.length; i++) {\n      var displayable = this._displayables[i];\n\n      if (displayable.contain(x, y)) {\n        return true;\n      }\n    }\n  }\n\n  return false;\n};\n\ninherits(IncrementalDisplayble, Displayble);\nvar _default = IncrementalDisplayble;\nmodule.exports = _default;","var echarts = require('echarts/lib/echarts');\n\nmodule.exports = echarts.graphic.extendShape({\n    type: 'ec-liquid-fill',\n\n    shape: {\n        waveLength: 0,\n        radius: 0,\n        radiusY: 0,\n        cx: 0,\n        cy: 0,\n        waterLevel: 0,\n        amplitude: 0,\n        phase: 0,\n        inverse: false\n    },\n\n    buildPath: function (ctx, shape) {\n        if (shape.radiusY == null) {\n            shape.radiusY = shape.radius;\n        }\n\n        /**\n         * We define a sine wave having 4 waves, and make sure at least 8 curves\n         * is drawn. Otherwise, it may cause blank area for some waves when\n         * wave length is large enough.\n         */\n        var curves = Math.max(\n            Math.ceil(2 * shape.radius / shape.waveLength * 4) * 2,\n            8\n        );\n\n        // map phase to [-Math.PI * 2, 0]\n        while (shape.phase < -Math.PI * 2) {\n            shape.phase += Math.PI * 2;\n        }\n        while (shape.phase > 0) {\n            shape.phase -= Math.PI * 2;\n        }\n        var phase = shape.phase / Math.PI / 2 * shape.waveLength;\n\n        var left = shape.cx - shape.radius + phase - shape.radius * 2;\n\n        /**\n         * top-left corner as start point\n         *\n         * draws this point\n         *  |\n         * \\|/\n         *  ~~~~~~~~\n         *  |      |\n         *  +------+\n         */\n        ctx.moveTo(left, shape.waterLevel);\n\n        /**\n         * top wave\n         *\n         * ~~~~~~~~ <- draws this sine wave\n         * |      |\n         * +------+\n         */\n        var waveRight = 0;\n        for (var c = 0; c < curves; ++c) {\n            var stage = c % 4;\n            var pos = getWaterPositions(c * shape.waveLength / 4, stage,\n                shape.waveLength, shape.amplitude);\n            ctx.bezierCurveTo(pos[0][0] + left, -pos[0][1] + shape.waterLevel,\n                pos[1][0] + left, -pos[1][1] + shape.waterLevel,\n                pos[2][0] + left, -pos[2][1] + shape.waterLevel);\n\n            if (c === curves - 1) {\n                waveRight = pos[2][0];\n            }\n        }\n\n        if (shape.inverse) {\n            /**\n             * top-right corner\n             *                  2. draws this line\n             *                          |\n             *                       +------+\n             * 3. draws this line -> |      | <- 1. draws this line\n             *                       ~~~~~~~~\n             */\n            ctx.lineTo(waveRight + left, shape.cy - shape.radiusY);\n            ctx.lineTo(left, shape.cy - shape.radiusY);\n            ctx.lineTo(left, shape.waterLevel);\n        }\n        else {\n            /**\n             * top-right corner\n             *\n             *                       ~~~~~~~~\n             * 3. draws this line -> |      | <- 1. draws this line\n             *                       +------+\n             *                          ^\n             *                          |\n             *                  2. draws this line\n             */\n            ctx.lineTo(waveRight + left, shape.cy + shape.radiusY);\n            ctx.lineTo(left, shape.cy + shape.radiusY);\n            ctx.lineTo(left, shape.waterLevel);\n        }\n\n        ctx.closePath();\n    }\n});\n\n\n\n/**\n * Using Bezier curves to fit sine wave.\n * There is 4 control points for each curve of wave,\n * which is at 1/4 wave length of the sine wave.\n *\n * The control points for a wave from (a) to (d) are a-b-c-d:\n *          c *----* d\n *     b *\n *       |\n * ... a * ..................\n *\n * whose positions are a: (0, 0), b: (0.5, 0.5), c: (1, 1), d: (PI / 2, 1)\n *\n * @param {number} x          x position of the left-most point (a)\n * @param {number} stage      0-3, stating which part of the wave it is\n * @param {number} waveLength wave length of the sine wave\n * @param {number} amplitude  wave amplitude\n */\nfunction getWaterPositions(x, stage, waveLength, amplitude) {\n    if (stage === 0) {\n        return [\n            [x + 1 / 2 * waveLength / Math.PI / 2, amplitude / 2],\n            [x + 1 / 2 * waveLength / Math.PI,     amplitude],\n            [x + waveLength / 4,                   amplitude]\n        ];\n    }\n    else if (stage === 1) {\n        return [\n            [x + 1 / 2 * waveLength / Math.PI / 2 * (Math.PI - 2),\n            amplitude],\n            [x + 1 / 2 * waveLength / Math.PI / 2 * (Math.PI - 1),\n            amplitude / 2],\n            [x + waveLength / 4,                   0]\n        ]\n    }\n    else if (stage === 2) {\n        return [\n            [x + 1 / 2 * waveLength / Math.PI / 2, -amplitude / 2],\n            [x + 1 / 2 * waveLength / Math.PI,     -amplitude],\n            [x + waveLength / 4,                   -amplitude]\n        ]\n    }\n    else {\n        return [\n            [x + 1 / 2 * waveLength / Math.PI / 2 * (Math.PI - 2),\n            -amplitude],\n            [x + 1 / 2 * waveLength / Math.PI / 2 * (Math.PI - 1),\n            -amplitude / 2],\n            [x + waveLength / 4,                   0]\n        ]\n    }\n}\n","\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar _util = require(\"zrender/lib/core/util\");\n\nvar createHashMap = _util.createHashMap;\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n// Pick color from palette for each data item.\n// Applicable for charts that require applying color palette\n// in data level (like pie, funnel, chord).\nfunction _default(seriesType) {\n  return {\n    getTargetSeries: function (ecModel) {\n      // Pie and funnel may use diferrent scope\n      var paletteScope = {};\n      var seiresModelMap = createHashMap();\n      ecModel.eachSeriesByType(seriesType, function (seriesModel) {\n        seriesModel.__paletteScope = paletteScope;\n        seiresModelMap.set(seriesModel.uid, seriesModel);\n      });\n      return seiresModelMap;\n    },\n    reset: function (seriesModel, ecModel) {\n      var dataAll = seriesModel.getRawData();\n      var idxMap = {};\n      var data = seriesModel.getData();\n      data.each(function (idx) {\n        var rawIdx = data.getRawIndex(idx);\n        idxMap[rawIdx] = idx;\n      });\n      dataAll.each(function (rawIdx) {\n        var filteredIdx = idxMap[rawIdx]; // If series.itemStyle.normal.color is a function. itemVisual may be encoded\n\n        var singleDataColor = filteredIdx != null && data.getItemVisual(filteredIdx, 'color', true);\n\n        if (!singleDataColor) {\n          // FIXME Performance\n          var itemModel = dataAll.getItemModel(rawIdx);\n          var color = itemModel.get('itemStyle.color') || seriesModel.getColorFromPalette(dataAll.getName(rawIdx) || rawIdx + '', seriesModel.__paletteScope, dataAll.count()); // Legend may use the visual info in data before processed\n\n          dataAll.setItemVisual(rawIdx, 'color', color); // Data is not filtered\n\n          if (filteredIdx != null) {\n            data.setItemVisual(filteredIdx, 'color', color);\n          }\n        } else {\n          // Set data all color for legend\n          dataAll.setItemVisual(rawIdx, 'color', singleDataColor);\n        }\n      });\n    }\n  };\n}\n\nmodule.exports = _default;"],"sourceRoot":""}