{"version":3,"sources":["webpack:///webpack/universalModuleDefinition","webpack:///echarts-liquidfill.min.js","webpack:///webpack/bootstrap c84def07b18966073981","webpack:///./index.js","webpack:///./~/zrender/lib/core/util.js","webpack:///./~/zrender/lib/graphic/Path.js","webpack:///./~/zrender/lib/core/vector.js","webpack:///./~/zrender/lib/core/BoundingRect.js","webpack:///./~/zrender/lib/core/curve.js","webpack:///./~/echarts/lib/config.js","webpack:///./~/zrender/lib/core/PathProxy.js","webpack:///./~/zrender/lib/graphic/Displayable.js","webpack:///external \"echarts\"","webpack:///./~/zrender/lib/core/matrix.js","webpack:///./~/zrender/lib/graphic/helper/image.js","webpack:///./~/echarts/lib/data/Source.js","webpack:///./~/echarts/lib/data/helper/sourceType.js","webpack:///./~/echarts/lib/util/model.js","webpack:///./~/zrender/lib/Element.js","webpack:///./~/zrender/lib/config.js","webpack:///./~/zrender/lib/contain/text.js","webpack:///./~/zrender/lib/contain/util.js","webpack:///./~/zrender/lib/core/LRU.js","webpack:///./~/zrender/lib/graphic/Gradient.js","webpack:///./~/zrender/lib/graphic/helper/fixShadow.js","webpack:///./~/zrender/lib/graphic/helper/poly.js","webpack:///./~/zrender/lib/graphic/helper/roundRect.js","webpack:///./~/zrender/lib/graphic/helper/text.js","webpack:///./~/zrender/lib/mixin/Transformable.js","webpack:///./~/zrender/lib/tool/color.js","webpack:///./~/echarts/lib/data/helper/completeDimensions.js","webpack:///./~/echarts/lib/data/helper/dimensionHelper.js","webpack:///./~/echarts/lib/data/helper/sourceHelper.js","webpack:///./~/echarts/lib/model/referHelper.js","webpack:///./~/echarts/lib/util/clazz.js","webpack:///./~/echarts/lib/util/graphic.js","webpack:///./~/echarts/lib/util/symbol.js","webpack:///./~/echarts/lib/visual/dataColor.js","webpack:///./~/zrender/lib/animation/Animator.js","webpack:///./~/zrender/lib/animation/Clip.js","webpack:///./~/zrender/lib/animation/easing.js","webpack:///./~/zrender/lib/contain/arc.js","webpack:///./~/zrender/lib/contain/cubic.js","webpack:///./~/zrender/lib/contain/line.js","webpack:///./~/zrender/lib/contain/path.js","webpack:///./~/zrender/lib/contain/quadratic.js","webpack:///./~/zrender/lib/contain/windingLine.js","webpack:///./~/zrender/lib/container/Group.js","webpack:///./~/zrender/lib/core/bbox.js","webpack:///./~/zrender/lib/core/env.js","webpack:///./~/zrender/lib/core/guid.js","webpack:///./~/zrender/lib/core/log.js","webpack:///./~/zrender/lib/graphic/CompoundPath.js","webpack:///./~/zrender/lib/graphic/Image.js","webpack:///./~/zrender/lib/graphic/IncrementalDisplayable.js","webpack:///./~/zrender/lib/graphic/LinearGradient.js","webpack:///./~/zrender/lib/graphic/Pattern.js","webpack:///./~/zrender/lib/graphic/RadialGradient.js","webpack:///./~/zrender/lib/graphic/Style.js","webpack:///./~/zrender/lib/graphic/Text.js","webpack:///./~/zrender/lib/graphic/helper/fixClipWithShadow.js","webpack:///./~/zrender/lib/graphic/helper/smoothBezier.js","webpack:///./~/zrender/lib/graphic/helper/smoothSpline.js","webpack:///./~/zrender/lib/graphic/mixin/RectText.js","webpack:///./~/zrender/lib/graphic/shape/Arc.js","webpack:///./~/zrender/lib/graphic/shape/BezierCurve.js","webpack:///./~/zrender/lib/graphic/shape/Circle.js","webpack:///./~/zrender/lib/graphic/shape/Line.js","webpack:///./~/zrender/lib/graphic/shape/Polygon.js","webpack:///./~/zrender/lib/graphic/shape/Polyline.js","webpack:///./~/zrender/lib/graphic/shape/Rect.js","webpack:///./~/zrender/lib/graphic/shape/Ring.js","webpack:///./~/zrender/lib/graphic/shape/Sector.js","webpack:///./~/zrender/lib/mixin/Animatable.js","webpack:///./~/zrender/lib/mixin/Eventful.js","webpack:///./~/zrender/lib/tool/path.js","webpack:///./~/zrender/lib/tool/transformPath.js","webpack:///./src/liquidFill.js","webpack:///./src/liquidFillLayout.js","webpack:///./src/liquidFillSeries.js","webpack:///./src/liquidFillView.js"],"names":["root","factory","exports","module","require","define","amd","echarts","this","__WEBPACK_EXTERNAL_MODULE_9__","modules","__webpack_require__","moduleId","installedModules","id","loaded","call","m","c","p","$override","name","fn","_ctx","methods","clone","source","result","typeStr","objToString","isPrimitive","i","len","length","TYPED_ARRAY","Ctor","constructor","from","BUILTIN_OBJECT","isDom","key","hasOwnProperty","merge","target","overwrite","isObject","targetProp","sourceProp","isArray","isBuiltInObject","mergeAll","targetAndSources","extend","defaults","overlay","getContext","createCanvas","indexOf","array","value","inherits","clazz","baseClazz","F","clazzPrototype","prototype","prop","superClass","mixin","isArrayLike","data","each","obj","cb","context","forEach","nativeForEach","map","nativeMap","push","reduce","memo","nativeReduce","filter","nativeFilter","find","bind","func","args","nativeSlice","arguments","apply","concat","curry","isFunction","isString","type","isTypedArray","nodeType","ownerDocument","eqNaN","retrieve","values","retrieve2","value0","value1","retrieve3","value2","slice","Function","normalizeCssArray","val","assert","condition","message","Error","trim","str","replace","setAsPrimitive","primitiveKey","HashMap","visit","isArr","thisMap","set","createHashMap","concatArray","a","b","newArray","offset","noop","[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]","Object","toString","arrayProto","Array","document","createElement","get","removeKey","Path","opts","Displayable","path","zrUtil","PathProxy","pathContain","Pattern","getCanvasPattern","abs","Math","pathProxyForDraw","__dirtyPath","strokeContainThreshold","brush","ctx","prevEl","style","hasStroke","hasFill","fill","stroke","hasFillGradient","colorStops","hasStrokeGradient","hasFillPattern","image","hasStrokePattern","setTransform","__dirty","rect","getBoundingRect","_fillGradient","getGradient","_strokeGradient","fillStyle","strokeStyle","lineDash","lineDashOffset","ctxLineDash","setLineDash","scale","getGlobalScale","setScale","beginPath","setLineDashOffset","buildPath","shape","rebuildPath","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","__zr","refresh","__clipTarget","animateShape","loop","animate","attrKV","setShape","transform","sqrt","Sub","extendFrom","defaultShape","thisShape","init","_default","create","out","ArrayCtor","v","add","v1","v2","scaleAndAdd","sub","lenSquare","mul","div","dot","s","normalize","d","distance","distanceSquare","negate","lerp","t","applyTransform","min","Float32Array","lengthSquare","dist","distSquare","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","cubicDerivativeAt","cubicRootAt","roots","A","B","C","n","t1","disc","K","t2","discSqrt","mathSqrt","Y1","Y2","mathPow","ONE_THIRD","T","theta","acos","ASqrt","tmp","cos","THREE_SQRT","sin","t3","cubicExtrema","extrema","cubicSubdivide","p01","p12","p23","p012","p123","p0123","cubicProjectPoint","x0","y0","x1","y1","x2","y2","x3","y3","prev","next","d1","d2","interval","Infinity","_v0","_t","_v1","v2DistSquare","EPSILON_NUMERIC","_v2","quadraticAt","quadraticDerivativeAt","quadraticRootAt","quadraticExtremum","divider","quadraticSubdivide","quadraticProjectPoint","_vector","v2Create","pow","global","dev","window","__DEV__","curve","bbox","_config","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","r","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","isEllipse","rotate","Element","Style","__clipPaths","RectText","invisible","z","z2","zlevel","draggable","dragging","silent","culling","cursor","rectHover","progressive","incremental","inplace","beforeBrush","afterBrush","rectContain","traverse","coord","animateStyle","setStyle","useStyle","identity","m1","m2","out0","out1","out2","out3","out4","out5","rad","aa","ac","atx","ab","ad","aty","st","ct","vx","vy","invert","det","findExistImage","newImageOrSrc","cachedImgObj","globalImageCache","createOrUpdateImage","hostEl","cbPayload","__zrImageSrc","pendingWrap","isImageReady","pending","Image","onload","imageOnLoad","put","__cachedImgObj","src","LRU","Source","fields","fromDataset","sourceFormat","SOURCE_FORMAT_KEYED_COLUMNS","SOURCE_FORMAT_UNKNOWN","seriesLayoutBy","SERIES_LAYOUT_BY_COLUMN","dimensionsDefine","encodeDefine","startIndex","dimensionsDetectCount","_util","_clazz","enableClassCheck","_sourceType","SOURCE_FORMAT_ORIGINAL","SOURCE_FORMAT_TYPED_ARRAY","seriesDataToSource","SOURCE_FORMAT_ARRAY_ROWS","SOURCE_FORMAT_OBJECT_ROWS","SERIES_LAYOUT_BY_ROW","normalizeToArray","defaultEmphasis","opt","subOpts","emphasis","subOptName","getDataItemValue","dataItem","Date","isDataItemOption","mappingToExists","exists","newCptOptions","index","exist","cptOption","option","isIdInner","makeIdAndName","mapResult","idMap","item","existCpt","keyInfo","DEFAULT_COMPONENT_NAME","idNum","compressBatches","batchA","batchB","makeMap","sourceBatch","otherMap","seriesId","dataIndices","dataIndex","otherDataIndices","j","lenj","mapToArray","isData","mapA","mapB","queryDataIndex","payload","dataIndexInside","indexOfRawIndex","indexOfName","makeInner","innerUniqueIndex","random","toFixed","hostObj","parseFinder","ecModel","finder","defaultMainType","has","parsedKey","match","mainType","queryType","toLowerCase","includeMainTypes","queryParam","models","queryComponents","setAttribute","dom","getAttribute","TEXT_STYLE_OPTIONS","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","debugMode","getWidth","font","DEFAULT_FONT","textWidthCache","textLines","split","l","measureText","textWidthCacheCounter","TEXT_CACHE_MAX","textAlign","textVerticalAlign","textPadding","rich","truncate","getRichTextRect","getPlainTextRect","contentBlock","parsePlainText","outerWidth","outerHeight","adjustTextX","adjustTextY","lineHeight","parseRichText","adjustTextPositionOnRect","textPosition","halfHeight","truncateText","containerWidth","ellipsis","options","prepareTruncateOptions","truncateSingleLine","join","maxIterations","minChar","cnCharWidth","ascCharWidth","placeholder","contentWidth","ellipsisWidth","textLine","subLength","estimateLength","floor","substr","charCode","charCodeAt","getLineHeight","padding","lines","truncOuterHeight","truncOuterWidth","lastIndex","STYLE_REG","exec","matchedIndex","pushTokens","substring","contentHeight","pendingList","stlPadding","truncateWidth","truncateHeight","line","tokens","token","tokenStyle","styleName","tokenHeight","textHeight","textLineHeight","textWidth","tokenWidth","tokenWidthNotSpecified","charAt","percentWidth","textBackgroundColor","bgImg","imageHelper","paddingW","remianTruncWidth","parseInt","block","isEmptyStr","strs","isLineHolder","tokensLen","makeFont","fontSize","fontFamily","fontStyle","fontWeight","textFont","normalizeRadian","angle","PI2","PI","LinkedList","head","tail","linkedListProto","insert","entry","Entry","insertEntry","remove","clear","maxSize","_list","_map","_maxSize","_lastRemovedEntry","LRUProto","list","removed","leastUsedEntry","Gradient","addColorStop","color","propName","SHADOW_PROPS","shadowBlur","shadowOffsetX","shadowOffsetY","textShadowBlur","textShadowOffsetX","textShadowOffsetY","textBoxShadowBlur","textBoxShadowOffsetX","textBoxShadowOffsetY","points","smooth","controlPoints","smoothBezier","smoothConstraint","cp1","cp2","smoothSpline","r1","r2","r3","r4","total","normalizeTextStyle","normalizeStyle","textContain","VALID_TEXT_ALIGN","textBaseline","VALID_TEXT_VERTICAL_ALIGN","renderText","renderRichText","renderPlainText","setCtx","__textCotentBlock","boxPos","getBoxPosition","baseX","baseY","applyTextRotation","boxY","textX","textY","needDrawBg","needDrawBackground","boxX","drawBackground","getTextXForPadding","textShadowColor","textStrokeWidth","textStroke","getStroke","textFill","getFill","strokeText","fillText","drawRichText","xLeft","lineTop","xRight","tokenCount","usedWidth","leftIndex","lineXLeft","lineXRight","rightIndex","placeToken","textRotation","origin","textOrigin","textBorderWidth","textBorderColor","isPlainBg","textBoxShadowColor","textBorderRadius","roundRectHelper","onBgImageLoaded","drawImage","blockHeiht","parsePercent","res","textDistance","textOffset","fixShadow","maxValue","lastIndexOf","parseFloat","needDrawText","left","right","center","top","bottom","middle","vector","mIdentity","position","rotation","transformableProto","needLocalTransform","parent","parentHasTransform","getLocalTransform","invTransform","tmpTransform","atan2","transformCoordToGlobal","clampCssByte","round","clampCssAngle","clampCssFloat","f","parseCssInt","parseCssFloat","cssHueToRgb","lerpNumber","setRgba","g","copyRgba","putToCache","colorStr","rgbaArr","lastRemovedArr","colorCache","parse","cached","kCSSColorTable","op","ep","fname","params","alpha","pop","hsla2rgba","iv","hsla","rgba","rgba2hsla","H","S","G","vMin","vMax","delta","deltaR","deltaG","deltaB","lift","level","colorArr","stringify","toHex","fastLerp","normalizedValue","colors","ceil","leftColor","rightColor","dv","fullOutput","modifyHSL","modifyAlpha","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","completeDimensions","sysDims","applyDim","resultItem","coordDim","coordDimIndex","OTHER_DIMENSIONS","otherDims","coordDimNameMap","isInstance","dimsDef","encodeDef","dataDimNameMap","dimCount","getDimCount","dimDefItem","userDimName","displayName","dataDims","validDataDims","resultDimIdx","availDimIdx","sysDimItem","sysDimIndex","sysDimItemDimsDef","sysDimItemOtherDims","ordinalMeta","isSysCoord","extra","extraPrefix","genName","extraFromZero","isExtraCoord","guessOrdinal","fromZero","_model","_sourceHelper","_dimensionHelper","summarizeDimensions","summary","encode","coordDimMap","defaultedLabel","dimensions","dimName","dimItem","getDimensionInfo","coordDimArr","mayLabelDimType","otherDim","otherDimArr","dimIndex","dataDimsOnCoord","encodeLabel","label","defaultedTooltip","encodeTooltip","tooltip","getDimensionTypeByAxis","axisType","dimType","detectSourceFormat","datasetModel","inner","getSource","seriesModel","resetSourceDefaulter","datasetMap","prepareSource","seriesOption","sourceHeader","getDatasetModel","datasetOption","completeResult","completeBySourceData","makeDefaultEncode","normalizeDimensionsDefine","findPotentialName","arrayRowsTravelFirst","objectRowsCollectDimensions","colArr","potentialNameDimIndex","dim","nameMap","count","maxLoop","firstIndex","coordSysDefine","getCoordSysDefineBySeries","encodeItemName","encodeSeriesName","seriesType","subType","nSeriesMap","cSeriesMap","uid","datasetRecord","categoryWayDim","valueWayDim","coordSysDims","firstCategoryDimIndex","dataDim","categoryAxisMap","firstNotOrdinal","doGuessOrdinal","nameDimIndex","itemName","seriesName","thisData","getComponent","datasetIndex","detectValue","isFinite","sample","row","_referHelper","coordSysName","axisMap","fetch","fetchers","isCategory","axisModel","cartesian2d","xAxisModel","getReferringComponents","yAxisModel","singleAxis","singleAxisModel","polar","polarModel","radiusAxisModel","findAxisModel","angleAxisModel","geo","parallel","parallelModel","parallelAxisIndex","axisIndex","axisDim","parseClassType","componentType","ret","main","TYPE_DELIMITER","checkClassType","test","enableClassExtend","RootClass","mandatoryMethods","$constructor","proto","ExtendedClass","superCall","superApply","Clz","classAttr","classBase","methodName","enableClassManagement","entity","makeContainer","container","storage","IS_CONTAINER","registerClass","Clazz","getClass","componentMainType","throwWhenNotFound","getClassesByMainType","o","hasClass","getAllClassMainTypes","types","hasSubTypes","registerWhenExtend","originalExtend","setReadOnly","properties","extendShape","extendPath","pathTool","extendFromString","makePath","layout","createFromString","boundingRect","centerGraphic","resizePath","makeImage","imageUrl","ZImage","img","aspect","pathRect","subPixelOptimizeLine","param","subPixelOptimize","subPixelOptimizeRect","originX","originY","originWidth","originHeight","positiveOrNegative","doubledPosition","hasFillOrStroke","fillOrStroke","liftColor","colorTool","cacheElementStl","el","__hoverStlDirty","hoverStyle","__hoverStl","normalStyle","__normalStl","doSingleEnterHover","__isHover","useHoverLayer","addHover","insideRollbackOpt","rollbackInsideStyle","applyInsideStyle","insideOriginalTextPosition","autoColor","doSingleLeaveHover","normalStl","removeHover","doEnterHover","child","doLeaveHover","setElementHoverStl","hoverStl","onElementMouseOver","e","__hoverSilentOnTouch","zrByTouch","__isEmphasis","onElementMouseOut","enterEmphasis","leaveEmphasis","setHoverStyle","hoverSilentOnTouch","on","setLabelStyle","emphasisStyle","normalModel","emphasisModel","normalSpecified","emphasisSpecified","EMPTY_OBJ","baseText","labelFetcher","labelDataIndex","labelDimIndex","showNormal","getShallow","showEmphasis","getFormattedLabel","defaultText","normalStyleText","emphasisStyleText","setTextStyle","textStyle","textStyleModel","specifiedTextStyle","isEmphasis","setTextStyleCommon","host","setText","labelModel","defaultColor","isRectText","labelRotate","richResult","globalTextStyle","richItemNames","getRichItemNames","richTextStyle","getModel","setTokenTextStyle","forceRich","richItemNameMap","parentModel","isBlock","getAutoColor","originalTextPosition","insideRollback","textTag","disableBox","useInsideStyle","getFont","gTextStyleModel","animateOrSetProps","isUpdate","props","animatableModel","animationEnabled","isAnimationEnabled","postfix","duration","animationEasing","animationDelay","getAnimationDelayParams","animateTo","stopAnimation","updateProps","initProps","getTransform","ancestor","mat","transformDirection","direction","hBase","vBase","vertex","groupTransition","g1","g2","getElMap","elMap","anid","getAnimatableProps","elMap1","oldEl","newProp","clipPointsByRect","point","clipRectByRect","targetRect","createIcon","iconStr","Group","Text","Circle","Sector","Ring","Polygon","Polyline","Rect","Line","BezierCurve","Arc","CompoundPath","LinearGradient","RadialGradient","IncrementalDisplayable","mergePath","symbolPathSetColor","innerColor","symbolStyle","symbolShape","symbolType","__isEmptyBrush","createSymbol","keepAspect","isEmpty","symbolPath","graphic","SymbolClz","setColor","Triangle","Diamond","Pin","asin","tanX","tanY","cpLen","cpLen2","Arrow","symbolCtors","roundRect","square","circle","diamond","pin","arrow","triangle","symbolShapeMakers","size","symbolBuildProxies","proxySymbol","getTargetSeries","paletteScope","seiresModelMap","eachSeriesByType","__paletteScope","reset","dataAll","getRawData","idxMap","getData","rawIdx","getRawIndex","filteredIdx","singleDataColor","getItemVisual","setItemVisual","itemModel","getItemModel","getColorFromPalette","getName","defaultGetter","defaultSetter","interpolateNumber","percent","interpolateString","interpolateArray","arrDim","len2","fillArr","arr0","arr1","arr0Len","arr1Len","isPreviousLarger","arraySlice","isNaN","isArraySame","catmullRomInterpolateArray","catmullRomInterpolate","v0","cloneValue","rgba2String","getArrayDim","keyframes","lastValue","createTrackClip","animator","easing","oneTrackDone","forceAnimate","getter","_getter","setter","_setter","useSpline","trackLen","trackMaxTime","firstVal","isValueArray","isValueColor","isValueString","sort","time","kfPercents","kfValues","prevValue","isAllValueEqual","colorArray","_target","start","lastFrame","lastFramePercent","onframe","frame","range","clip","Clip","life","_loop","delay","_delay","ondestroy","Animator","_tracks","_clipCount","_doneList","_onframeList","_clipList","when","tracks","during","callback","pause","_paused","resume","isPaused","_doneCallback","doneList","lastClip","self","clipCount","addClip","oldOnFrame","stop","forwardToLast","clipList","removeClip","done","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","_l","_a","_b","_s","isAroundEqual","swapExtrema","windingCubic","nRoots","y0_","y1_","nExtrema","unit","x_","windingQuadratic","y_","windingArc","diff","dir","containPath","isStroke","windingLine","cubic","quadratic","_x","_curve","_children","__storage","children","childAt","childOfName","childCount","_doAdd","addBefore","nextSibling","splice","addToStorage","addChildrenToStorage","delFromStorage","delChildrenFromStorage","removeAll","eachChild","includeChildren","tmpRect","tmpMat","childRect","fromPoints","xDim","yDim","tx","ty","vec2Min","vec2Max","end","extremity","detect","ua","os","browser","firefox","ie","edge","weChat","version","node","canvasSupported","svgSupported","SVGRect","touchEventsSupported","pointerEventsSupported","env","wx","wxa","worker","navigator","userAgent","idStart","log","console","paths","_updatePathDirty","_image","sWidth","sHeight","IncrementalDisplayble","Displayble","_displayables","_temporaryDisplayables","_cursor","notClear","clearDisplaybles","addDisplayable","displayable","notPersistent","addDisplayables","displayables","eachPendingDisplayable","globalCoord","repeat","createPattern","createLinearGradient","canvasGradient","createRadialGradient","STYLE_COMMON_PROPS","opacity","textRect","transformText","blend","prevStyle","firstDraw","globalAlpha","globalCompositeOperation","otherStyle","newStyle","method","styleProto","textHelper","shadowColor","orignalBrush","modified","clipPaths","shadowTemp","isLoop","constraint","prevPoint","nextPoint","cps","v2Min","v2Max","v2Clone","v2Sub","v2Scale","d0","v2Distance","sum","cp0","v2Add","shift","interpolate","segs","pos","w2","w3","save","restore","clockwise","unitX","unitY","someVectorAt","isTangent","cpx2","cpy2","cpx1","cpy1","pointAt","tangentAt","polyHelper","r0","fixClipWithShadow","animatingShape","pathSplitted","_animateToShallow","objShallow","propertyCount","arrySlice","_$handlers","one","event","handler","_h","isSilent","off","newList","trigger","argLen","triggerWithContext","processArc","fa","psiDeg","xp","yp","lambda","cxp","cyp","vAngle","u","vRatio","createPathProxyFromString","cs","cc","RegExp","prevCmd","arr","cpx","cpy","ctlPtx","ctlPty","createPathOptions","pathProxy","transformPath","pathEls","pathList","pathEl","pathBundle","vMag","nPoint","mathAtan2","registerVisual","util","getWaterPositions","stage","waveLength","amplitude","waterLevel","phase","inverse","curves","waveRight","extendSeriesModel","visualColorAccessPath","optionUpdated","gridSize","getInitialData","List","initData","defaultOption","period","waveAnimation","animationEasingUpdate","animationDuration","animationDurationUpdate","outline","borderDistance","itemStyle","borderColor","borderWidth","backgroundStyle","insideColor","align","baseline","numberUtil","number","symbolUtil","LiquidLayout","extendChartView","render","api","getPath","isForClipping","symbol","bouding","isFillContainer","getOutline","outlinePath","outterRadius","getItemStyle","getBackground","strokePath","fillPath","group","getWave","isInverse","oldWave","radiusX","radiusY","itemStyleModel","seriesColor","wave","_waterLevel","setWaveAnimation","maxSpeed","defaultSpeed","cnt","speed","phaseOffset","error","wavePath","getText","waves","formatLabel","formatted","defaultVal","defaultLabel","textOption","outsideTextRect","insideTextRect","insColor","boundingCircle","getHeight","outlineDistance","outlineBorderWidth","showOutline","innerRadius","paddingRadius","oldData","_data","setItemGraphicEl","newIdx","oldIdx","waveElement","getItemGraphicEl","newWave","assign","execute","dispose"],"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})(this, function(__WEBPACK_EXTERNAL_MODULE_9__) {\nreturn \n\n\n// WEBPACK FOOTER //\n// webpack/universalModuleDefinition","(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})(this, function(__WEBPACK_EXTERNAL_MODULE_9__) {\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/******/\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\texports: {},\n/******/ \t\t\tid: moduleId,\n/******/ \t\t\tloaded: false\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.loaded = 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// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(0);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tmodule.exports = __webpack_require__(74);\n\n\n/***/ },\n/* 1 */\n/***/ function(module, exports) {\n\n\t/**\n\t * @module zrender/core/util\n\t */\n\t// 用于处理merge时无法遍历Date等对象的问题\n\tvar BUILTIN_OBJECT = {\n\t  '[object Function]': 1,\n\t  '[object RegExp]': 1,\n\t  '[object Date]': 1,\n\t  '[object Error]': 1,\n\t  '[object CanvasGradient]': 1,\n\t  '[object CanvasPattern]': 1,\n\t  // For node-canvas\n\t  '[object Image]': 1,\n\t  '[object Canvas]': 1\n\t};\n\tvar TYPED_ARRAY = {\n\t  '[object Int8Array]': 1,\n\t  '[object Uint8Array]': 1,\n\t  '[object Uint8ClampedArray]': 1,\n\t  '[object Int16Array]': 1,\n\t  '[object Uint16Array]': 1,\n\t  '[object Int32Array]': 1,\n\t  '[object Uint32Array]': 1,\n\t  '[object Float32Array]': 1,\n\t  '[object Float64Array]': 1\n\t};\n\tvar objToString = Object.prototype.toString;\n\tvar arrayProto = Array.prototype;\n\tvar nativeForEach = arrayProto.forEach;\n\tvar nativeFilter = arrayProto.filter;\n\tvar nativeSlice = arrayProto.slice;\n\tvar nativeMap = arrayProto.map;\n\tvar nativeReduce = arrayProto.reduce; // Avoid assign to an exported variable, for transforming to cjs.\n\t\n\tvar methods = {};\n\t\n\tfunction $override(name, fn) {\n\t  // Clear ctx instance for different environment\n\t  if (name === 'createCanvas') {\n\t    _ctx = null;\n\t  }\n\t\n\t  methods[name] = fn;\n\t}\n\t/**\n\t * Those data types can be cloned:\n\t *     Plain object, Array, TypedArray, number, string, null, undefined.\n\t * Those data types will be assgined using the orginal data:\n\t *     BUILTIN_OBJECT\n\t * Instance of user defined class will be cloned to a plain object, without\n\t * properties in prototype.\n\t * Other data types is not supported (not sure what will happen).\n\t *\n\t * Caution: do not support clone Date, for performance consideration.\n\t * (There might be a large number of date in `series.data`).\n\t * So date should not be modified in and out of echarts.\n\t *\n\t * @param {*} source\n\t * @return {*} new\n\t */\n\t\n\t\n\tfunction clone(source) {\n\t  if (source == null || typeof source != 'object') {\n\t    return source;\n\t  }\n\t\n\t  var result = source;\n\t  var typeStr = objToString.call(source);\n\t\n\t  if (typeStr === '[object Array]') {\n\t    if (!isPrimitive(source)) {\n\t      result = [];\n\t\n\t      for (var i = 0, len = source.length; i < len; i++) {\n\t        result[i] = clone(source[i]);\n\t      }\n\t    }\n\t  } else if (TYPED_ARRAY[typeStr]) {\n\t    if (!isPrimitive(source)) {\n\t      var Ctor = source.constructor;\n\t\n\t      if (source.constructor.from) {\n\t        result = Ctor.from(source);\n\t      } else {\n\t        result = new Ctor(source.length);\n\t\n\t        for (var i = 0, len = source.length; i < len; i++) {\n\t          result[i] = clone(source[i]);\n\t        }\n\t      }\n\t    }\n\t  } else if (!BUILTIN_OBJECT[typeStr] && !isPrimitive(source) && !isDom(source)) {\n\t    result = {};\n\t\n\t    for (var key in source) {\n\t      if (source.hasOwnProperty(key)) {\n\t        result[key] = clone(source[key]);\n\t      }\n\t    }\n\t  }\n\t\n\t  return result;\n\t}\n\t/**\n\t * @memberOf module:zrender/core/util\n\t * @param {*} target\n\t * @param {*} source\n\t * @param {boolean} [overwrite=false]\n\t */\n\t\n\t\n\tfunction merge(target, source, overwrite) {\n\t  // We should escapse that source is string\n\t  // and enter for ... in ...\n\t  if (!isObject(source) || !isObject(target)) {\n\t    return overwrite ? clone(source) : target;\n\t  }\n\t\n\t  for (var key in source) {\n\t    if (source.hasOwnProperty(key)) {\n\t      var targetProp = target[key];\n\t      var sourceProp = source[key];\n\t\n\t      if (isObject(sourceProp) && isObject(targetProp) && !isArray(sourceProp) && !isArray(targetProp) && !isDom(sourceProp) && !isDom(targetProp) && !isBuiltInObject(sourceProp) && !isBuiltInObject(targetProp) && !isPrimitive(sourceProp) && !isPrimitive(targetProp)) {\n\t        // 如果需要递归覆盖，就递归调用merge\n\t        merge(targetProp, sourceProp, overwrite);\n\t      } else if (overwrite || !(key in target)) {\n\t        // 否则只处理overwrite为true，或者在目标对象中没有此属性的情况\n\t        // NOTE，在 target[key] 不存在的时候也是直接覆盖\n\t        target[key] = clone(source[key], true);\n\t      }\n\t    }\n\t  }\n\t\n\t  return target;\n\t}\n\t/**\n\t * @param {Array} targetAndSources The first item is target, and the rests are source.\n\t * @param {boolean} [overwrite=false]\n\t * @return {*} target\n\t */\n\t\n\t\n\tfunction mergeAll(targetAndSources, overwrite) {\n\t  var result = targetAndSources[0];\n\t\n\t  for (var i = 1, len = targetAndSources.length; i < len; i++) {\n\t    result = merge(result, targetAndSources[i], overwrite);\n\t  }\n\t\n\t  return result;\n\t}\n\t/**\n\t * @param {*} target\n\t * @param {*} source\n\t * @memberOf module:zrender/core/util\n\t */\n\t\n\t\n\tfunction extend(target, source) {\n\t  for (var key in source) {\n\t    if (source.hasOwnProperty(key)) {\n\t      target[key] = source[key];\n\t    }\n\t  }\n\t\n\t  return target;\n\t}\n\t/**\n\t * @param {*} target\n\t * @param {*} source\n\t * @param {boolean} [overlay=false]\n\t * @memberOf module:zrender/core/util\n\t */\n\t\n\t\n\tfunction defaults(target, source, overlay) {\n\t  for (var key in source) {\n\t    if (source.hasOwnProperty(key) && (overlay ? source[key] != null : target[key] == null)) {\n\t      target[key] = source[key];\n\t    }\n\t  }\n\t\n\t  return target;\n\t}\n\t\n\tvar createCanvas = function () {\n\t  return methods.createCanvas();\n\t};\n\t\n\tmethods.createCanvas = function () {\n\t  return document.createElement('canvas');\n\t}; // FIXME\n\t\n\t\n\tvar _ctx;\n\t\n\tfunction getContext() {\n\t  if (!_ctx) {\n\t    // Use util.createCanvas instead of createCanvas\n\t    // because createCanvas may be overwritten in different environment\n\t    _ctx = createCanvas().getContext('2d');\n\t  }\n\t\n\t  return _ctx;\n\t}\n\t/**\n\t * 查询数组中元素的index\n\t * @memberOf module:zrender/core/util\n\t */\n\t\n\t\n\tfunction indexOf(array, value) {\n\t  if (array) {\n\t    if (array.indexOf) {\n\t      return array.indexOf(value);\n\t    }\n\t\n\t    for (var i = 0, len = array.length; i < len; i++) {\n\t      if (array[i] === value) {\n\t        return i;\n\t      }\n\t    }\n\t  }\n\t\n\t  return -1;\n\t}\n\t/**\n\t * 构造类继承关系\n\t *\n\t * @memberOf module:zrender/core/util\n\t * @param {Function} clazz 源类\n\t * @param {Function} baseClazz 基类\n\t */\n\t\n\t\n\tfunction inherits(clazz, baseClazz) {\n\t  var clazzPrototype = clazz.prototype;\n\t\n\t  function F() {}\n\t\n\t  F.prototype = baseClazz.prototype;\n\t  clazz.prototype = new F();\n\t\n\t  for (var prop in clazzPrototype) {\n\t    clazz.prototype[prop] = clazzPrototype[prop];\n\t  }\n\t\n\t  clazz.prototype.constructor = clazz;\n\t  clazz.superClass = baseClazz;\n\t}\n\t/**\n\t * @memberOf module:zrender/core/util\n\t * @param {Object|Function} target\n\t * @param {Object|Function} sorce\n\t * @param {boolean} overlay\n\t */\n\t\n\t\n\tfunction mixin(target, source, overlay) {\n\t  target = 'prototype' in target ? target.prototype : target;\n\t  source = 'prototype' in source ? source.prototype : source;\n\t  defaults(target, source, overlay);\n\t}\n\t/**\n\t * Consider typed array.\n\t * @param {Array|TypedArray} data\n\t */\n\t\n\t\n\tfunction isArrayLike(data) {\n\t  if (!data) {\n\t    return;\n\t  }\n\t\n\t  if (typeof data == 'string') {\n\t    return false;\n\t  }\n\t\n\t  return typeof data.length == 'number';\n\t}\n\t/**\n\t * 数组或对象遍历\n\t * @memberOf module:zrender/core/util\n\t * @param {Object|Array} obj\n\t * @param {Function} cb\n\t * @param {*} [context]\n\t */\n\t\n\t\n\tfunction each(obj, cb, context) {\n\t  if (!(obj && cb)) {\n\t    return;\n\t  }\n\t\n\t  if (obj.forEach && obj.forEach === nativeForEach) {\n\t    obj.forEach(cb, context);\n\t  } else if (obj.length === +obj.length) {\n\t    for (var i = 0, len = obj.length; i < len; i++) {\n\t      cb.call(context, obj[i], i, obj);\n\t    }\n\t  } else {\n\t    for (var key in obj) {\n\t      if (obj.hasOwnProperty(key)) {\n\t        cb.call(context, obj[key], key, obj);\n\t      }\n\t    }\n\t  }\n\t}\n\t/**\n\t * 数组映射\n\t * @memberOf module:zrender/core/util\n\t * @param {Array} obj\n\t * @param {Function} cb\n\t * @param {*} [context]\n\t * @return {Array}\n\t */\n\t\n\t\n\tfunction map(obj, cb, context) {\n\t  if (!(obj && cb)) {\n\t    return;\n\t  }\n\t\n\t  if (obj.map && obj.map === nativeMap) {\n\t    return obj.map(cb, context);\n\t  } else {\n\t    var result = [];\n\t\n\t    for (var i = 0, len = obj.length; i < len; i++) {\n\t      result.push(cb.call(context, obj[i], i, obj));\n\t    }\n\t\n\t    return result;\n\t  }\n\t}\n\t/**\n\t * @memberOf module:zrender/core/util\n\t * @param {Array} obj\n\t * @param {Function} cb\n\t * @param {Object} [memo]\n\t * @param {*} [context]\n\t * @return {Array}\n\t */\n\t\n\t\n\tfunction reduce(obj, cb, memo, context) {\n\t  if (!(obj && cb)) {\n\t    return;\n\t  }\n\t\n\t  if (obj.reduce && obj.reduce === nativeReduce) {\n\t    return obj.reduce(cb, memo, context);\n\t  } else {\n\t    for (var i = 0, len = obj.length; i < len; i++) {\n\t      memo = cb.call(context, memo, obj[i], i, obj);\n\t    }\n\t\n\t    return memo;\n\t  }\n\t}\n\t/**\n\t * 数组过滤\n\t * @memberOf module:zrender/core/util\n\t * @param {Array} obj\n\t * @param {Function} cb\n\t * @param {*} [context]\n\t * @return {Array}\n\t */\n\t\n\t\n\tfunction filter(obj, cb, context) {\n\t  if (!(obj && cb)) {\n\t    return;\n\t  }\n\t\n\t  if (obj.filter && obj.filter === nativeFilter) {\n\t    return obj.filter(cb, context);\n\t  } else {\n\t    var result = [];\n\t\n\t    for (var i = 0, len = obj.length; i < len; i++) {\n\t      if (cb.call(context, obj[i], i, obj)) {\n\t        result.push(obj[i]);\n\t      }\n\t    }\n\t\n\t    return result;\n\t  }\n\t}\n\t/**\n\t * 数组项查找\n\t * @memberOf module:zrender/core/util\n\t * @param {Array} obj\n\t * @param {Function} cb\n\t * @param {*} [context]\n\t * @return {*}\n\t */\n\t\n\t\n\tfunction find(obj, cb, context) {\n\t  if (!(obj && cb)) {\n\t    return;\n\t  }\n\t\n\t  for (var i = 0, len = obj.length; i < len; i++) {\n\t    if (cb.call(context, obj[i], i, obj)) {\n\t      return obj[i];\n\t    }\n\t  }\n\t}\n\t/**\n\t * @memberOf module:zrender/core/util\n\t * @param {Function} func\n\t * @param {*} context\n\t * @return {Function}\n\t */\n\t\n\t\n\tfunction bind(func, context) {\n\t  var args = nativeSlice.call(arguments, 2);\n\t  return function () {\n\t    return func.apply(context, args.concat(nativeSlice.call(arguments)));\n\t  };\n\t}\n\t/**\n\t * @memberOf module:zrender/core/util\n\t * @param {Function} func\n\t * @return {Function}\n\t */\n\t\n\t\n\tfunction curry(func) {\n\t  var args = nativeSlice.call(arguments, 1);\n\t  return function () {\n\t    return func.apply(this, args.concat(nativeSlice.call(arguments)));\n\t  };\n\t}\n\t/**\n\t * @memberOf module:zrender/core/util\n\t * @param {*} value\n\t * @return {boolean}\n\t */\n\t\n\t\n\tfunction isArray(value) {\n\t  return objToString.call(value) === '[object Array]';\n\t}\n\t/**\n\t * @memberOf module:zrender/core/util\n\t * @param {*} value\n\t * @return {boolean}\n\t */\n\t\n\t\n\tfunction isFunction(value) {\n\t  return typeof value === 'function';\n\t}\n\t/**\n\t * @memberOf module:zrender/core/util\n\t * @param {*} value\n\t * @return {boolean}\n\t */\n\t\n\t\n\tfunction isString(value) {\n\t  return objToString.call(value) === '[object String]';\n\t}\n\t/**\n\t * @memberOf module:zrender/core/util\n\t * @param {*} value\n\t * @return {boolean}\n\t */\n\t\n\t\n\tfunction isObject(value) {\n\t  // Avoid a V8 JIT bug in Chrome 19-20.\n\t  // See https://code.google.com/p/v8/issues/detail?id=2291 for more details.\n\t  var type = typeof value;\n\t  return type === 'function' || !!value && type == 'object';\n\t}\n\t/**\n\t * @memberOf module:zrender/core/util\n\t * @param {*} value\n\t * @return {boolean}\n\t */\n\t\n\t\n\tfunction isBuiltInObject(value) {\n\t  return !!BUILTIN_OBJECT[objToString.call(value)];\n\t}\n\t/**\n\t * @memberOf module:zrender/core/util\n\t * @param {*} value\n\t * @return {boolean}\n\t */\n\t\n\t\n\tfunction isTypedArray(value) {\n\t  return !!TYPED_ARRAY[objToString.call(value)];\n\t}\n\t/**\n\t * @memberOf module:zrender/core/util\n\t * @param {*} value\n\t * @return {boolean}\n\t */\n\t\n\t\n\tfunction isDom(value) {\n\t  return typeof value === 'object' && typeof value.nodeType === 'number' && typeof value.ownerDocument === 'object';\n\t}\n\t/**\n\t * Whether is exactly NaN. Notice isNaN('a') returns true.\n\t * @param {*} value\n\t * @return {boolean}\n\t */\n\t\n\t\n\tfunction eqNaN(value) {\n\t  return value !== value;\n\t}\n\t/**\n\t * If value1 is not null, then return value1, otherwise judget rest of values.\n\t * Low performance.\n\t * @memberOf module:zrender/core/util\n\t * @return {*} Final value\n\t */\n\t\n\t\n\tfunction retrieve(values) {\n\t  for (var i = 0, len = arguments.length; i < len; i++) {\n\t    if (arguments[i] != null) {\n\t      return arguments[i];\n\t    }\n\t  }\n\t}\n\t\n\tfunction retrieve2(value0, value1) {\n\t  return value0 != null ? value0 : value1;\n\t}\n\t\n\tfunction retrieve3(value0, value1, value2) {\n\t  return value0 != null ? value0 : value1 != null ? value1 : value2;\n\t}\n\t/**\n\t * @memberOf module:zrender/core/util\n\t * @param {Array} arr\n\t * @param {number} startIndex\n\t * @param {number} endIndex\n\t * @return {Array}\n\t */\n\t\n\t\n\tfunction slice() {\n\t  return Function.call.apply(nativeSlice, arguments);\n\t}\n\t/**\n\t * Normalize css liked array configuration\n\t * e.g.\n\t *  3 => [3, 3, 3, 3]\n\t *  [4, 2] => [4, 2, 4, 2]\n\t *  [4, 3, 2] => [4, 3, 2, 3]\n\t * @param {number|Array.<number>} val\n\t * @return {Array.<number>}\n\t */\n\t\n\t\n\tfunction normalizeCssArray(val) {\n\t  if (typeof val === 'number') {\n\t    return [val, val, val, val];\n\t  }\n\t\n\t  var len = val.length;\n\t\n\t  if (len === 2) {\n\t    // vertical | horizontal\n\t    return [val[0], val[1], val[0], val[1]];\n\t  } else if (len === 3) {\n\t    // top | horizontal | bottom\n\t    return [val[0], val[1], val[2], val[1]];\n\t  }\n\t\n\t  return val;\n\t}\n\t/**\n\t * @memberOf module:zrender/core/util\n\t * @param {boolean} condition\n\t * @param {string} message\n\t */\n\t\n\t\n\tfunction assert(condition, message) {\n\t  if (!condition) {\n\t    throw new Error(message);\n\t  }\n\t}\n\t/**\n\t * @memberOf module:zrender/core/util\n\t * @param {string} str string to be trimed\n\t * @return {string} trimed string\n\t */\n\t\n\t\n\tfunction trim(str) {\n\t  if (str == null) {\n\t    return null;\n\t  } else if (typeof str.trim === 'function') {\n\t    return str.trim();\n\t  } else {\n\t    return str.replace(/^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g, '');\n\t  }\n\t}\n\t\n\tvar primitiveKey = '__ec_primitive__';\n\t/**\n\t * Set an object as primitive to be ignored traversing children in clone or merge\n\t */\n\t\n\tfunction setAsPrimitive(obj) {\n\t  obj[primitiveKey] = true;\n\t}\n\t\n\tfunction isPrimitive(obj) {\n\t  return obj[primitiveKey];\n\t}\n\t/**\n\t * @constructor\n\t * @param {Object} obj Only apply `ownProperty`.\n\t */\n\t\n\t\n\tfunction HashMap(obj) {\n\t  var isArr = isArray(obj);\n\t  var thisMap = this;\n\t  obj instanceof HashMap ? obj.each(visit) : obj && each(obj, visit);\n\t\n\t  function visit(value, key) {\n\t    isArr ? thisMap.set(value, key) : thisMap.set(key, value);\n\t  }\n\t} // Add prefix to avoid conflict with Object.prototype.\n\t\n\t\n\tHashMap.prototype = {\n\t  constructor: HashMap,\n\t  // Do not provide `has` method to avoid defining what is `has`.\n\t  // (We usually treat `null` and `undefined` as the same, different\n\t  // from ES6 Map).\n\t  get: function (key) {\n\t    return this.hasOwnProperty(key) ? this[key] : null;\n\t  },\n\t  set: function (key, value) {\n\t    // Comparing with invocation chaining, `return value` is more commonly\n\t    // used in this case: `var someVal = map.set('a', genVal());`\n\t    return this[key] = value;\n\t  },\n\t  // Although util.each can be performed on this hashMap directly, user\n\t  // should not use the exposed keys, who are prefixed.\n\t  each: function (cb, context) {\n\t    context !== void 0 && (cb = bind(cb, context));\n\t\n\t    for (var key in this) {\n\t      this.hasOwnProperty(key) && cb(this[key], key);\n\t    }\n\t  },\n\t  // Do not use this method if performance sensitive.\n\t  removeKey: function (key) {\n\t    delete this[key];\n\t  }\n\t};\n\t\n\tfunction createHashMap(obj) {\n\t  return new HashMap(obj);\n\t}\n\t\n\tfunction concatArray(a, b) {\n\t  var newArray = new a.constructor(a.length + b.length);\n\t\n\t  for (var i = 0; i < a.length; i++) {\n\t    newArray[i] = a[i];\n\t  }\n\t\n\t  var offset = a.length;\n\t\n\t  for (i = 0; i < b.length; i++) {\n\t    newArray[i + offset] = b[i];\n\t  }\n\t\n\t  return newArray;\n\t}\n\t\n\tfunction noop() {}\n\t\n\texports.$override = $override;\n\texports.clone = clone;\n\texports.merge = merge;\n\texports.mergeAll = mergeAll;\n\texports.extend = extend;\n\texports.defaults = defaults;\n\texports.createCanvas = createCanvas;\n\texports.getContext = getContext;\n\texports.indexOf = indexOf;\n\texports.inherits = inherits;\n\texports.mixin = mixin;\n\texports.isArrayLike = isArrayLike;\n\texports.each = each;\n\texports.map = map;\n\texports.reduce = reduce;\n\texports.filter = filter;\n\texports.find = find;\n\texports.bind = bind;\n\texports.curry = curry;\n\texports.isArray = isArray;\n\texports.isFunction = isFunction;\n\texports.isString = isString;\n\texports.isObject = isObject;\n\texports.isBuiltInObject = isBuiltInObject;\n\texports.isTypedArray = isTypedArray;\n\texports.isDom = isDom;\n\texports.eqNaN = eqNaN;\n\texports.retrieve = retrieve;\n\texports.retrieve2 = retrieve2;\n\texports.retrieve3 = retrieve3;\n\texports.slice = slice;\n\texports.normalizeCssArray = normalizeCssArray;\n\texports.assert = assert;\n\texports.trim = trim;\n\texports.setAsPrimitive = setAsPrimitive;\n\texports.isPrimitive = isPrimitive;\n\texports.createHashMap = createHashMap;\n\texports.concatArray = concatArray;\n\texports.noop = noop;\n\n/***/ },\n/* 2 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar Displayable = __webpack_require__(8);\n\t\n\tvar zrUtil = __webpack_require__(1);\n\t\n\tvar PathProxy = __webpack_require__(7);\n\t\n\tvar pathContain = __webpack_require__(41);\n\t\n\tvar Pattern = __webpack_require__(53);\n\t\n\tvar getCanvasPattern = Pattern.prototype.getCanvasPattern;\n\tvar abs = Math.abs;\n\tvar pathProxyForDraw = new PathProxy(true);\n\t/**\n\t * @alias module:zrender/graphic/Path\n\t * @extends module:zrender/graphic/Displayable\n\t * @constructor\n\t * @param {Object} opts\n\t */\n\t\n\tfunction Path(opts) {\n\t  Displayable.call(this, opts);\n\t  /**\n\t   * @type {module:zrender/core/PathProxy}\n\t   * @readOnly\n\t   */\n\t\n\t  this.path = null;\n\t}\n\t\n\tPath.prototype = {\n\t  constructor: Path,\n\t  type: 'path',\n\t  __dirtyPath: true,\n\t  strokeContainThreshold: 5,\n\t  brush: function (ctx, prevEl) {\n\t    var style = this.style;\n\t    var path = this.path || pathProxyForDraw;\n\t    var hasStroke = style.hasStroke();\n\t    var hasFill = style.hasFill();\n\t    var fill = style.fill;\n\t    var stroke = style.stroke;\n\t    var hasFillGradient = hasFill && !!fill.colorStops;\n\t    var hasStrokeGradient = hasStroke && !!stroke.colorStops;\n\t    var hasFillPattern = hasFill && !!fill.image;\n\t    var hasStrokePattern = hasStroke && !!stroke.image;\n\t    style.bind(ctx, this, prevEl);\n\t    this.setTransform(ctx);\n\t\n\t    if (this.__dirty) {\n\t      var rect; // Update gradient because bounding rect may changed\n\t\n\t      if (hasFillGradient) {\n\t        rect = rect || this.getBoundingRect();\n\t        this._fillGradient = style.getGradient(ctx, fill, rect);\n\t      }\n\t\n\t      if (hasStrokeGradient) {\n\t        rect = rect || this.getBoundingRect();\n\t        this._strokeGradient = style.getGradient(ctx, stroke, rect);\n\t      }\n\t    } // Use the gradient or pattern\n\t\n\t\n\t    if (hasFillGradient) {\n\t      // PENDING If may have affect the state\n\t      ctx.fillStyle = this._fillGradient;\n\t    } else if (hasFillPattern) {\n\t      ctx.fillStyle = getCanvasPattern.call(fill, ctx);\n\t    }\n\t\n\t    if (hasStrokeGradient) {\n\t      ctx.strokeStyle = this._strokeGradient;\n\t    } else if (hasStrokePattern) {\n\t      ctx.strokeStyle = getCanvasPattern.call(stroke, ctx);\n\t    }\n\t\n\t    var lineDash = style.lineDash;\n\t    var lineDashOffset = style.lineDashOffset;\n\t    var ctxLineDash = !!ctx.setLineDash; // Update path sx, sy\n\t\n\t    var scale = this.getGlobalScale();\n\t    path.setScale(scale[0], scale[1]); // Proxy context\n\t    // Rebuild path in following 2 cases\n\t    // 1. Path is dirty\n\t    // 2. Path needs javascript implemented lineDash stroking.\n\t    //    In this case, lineDash information will not be saved in PathProxy\n\t\n\t    if (this.__dirtyPath || lineDash && !ctxLineDash && hasStroke) {\n\t      path.beginPath(ctx); // Setting line dash before build path\n\t\n\t      if (lineDash && !ctxLineDash) {\n\t        path.setLineDash(lineDash);\n\t        path.setLineDashOffset(lineDashOffset);\n\t      }\n\t\n\t      this.buildPath(path, this.shape, false); // Clear path dirty flag\n\t\n\t      if (this.path) {\n\t        this.__dirtyPath = false;\n\t      }\n\t    } else {\n\t      // Replay path building\n\t      ctx.beginPath();\n\t      this.path.rebuildPath(ctx);\n\t    }\n\t\n\t    hasFill && path.fill(ctx);\n\t\n\t    if (lineDash && ctxLineDash) {\n\t      ctx.setLineDash(lineDash);\n\t      ctx.lineDashOffset = lineDashOffset;\n\t    }\n\t\n\t    hasStroke && path.stroke(ctx);\n\t\n\t    if (lineDash && ctxLineDash) {\n\t      // PENDING\n\t      // Remove lineDash\n\t      ctx.setLineDash([]);\n\t    } // Draw rect text\n\t\n\t\n\t    if (style.text != null) {\n\t      // Only restore transform when needs draw text.\n\t      this.restoreTransform(ctx);\n\t      this.drawRectText(ctx, this.getBoundingRect());\n\t    }\n\t  },\n\t  // When bundling path, some shape may decide if use moveTo to begin a new subpath or closePath\n\t  // Like in circle\n\t  buildPath: function (ctx, shapeCfg, inBundle) {},\n\t  createPathProxy: function () {\n\t    this.path = new PathProxy();\n\t  },\n\t  getBoundingRect: function () {\n\t    var rect = this._rect;\n\t    var style = this.style;\n\t    var needsUpdateRect = !rect;\n\t\n\t    if (needsUpdateRect) {\n\t      var path = this.path;\n\t\n\t      if (!path) {\n\t        // Create path on demand.\n\t        path = this.path = new PathProxy();\n\t      }\n\t\n\t      if (this.__dirtyPath) {\n\t        path.beginPath();\n\t        this.buildPath(path, this.shape, false);\n\t      }\n\t\n\t      rect = path.getBoundingRect();\n\t    }\n\t\n\t    this._rect = rect;\n\t\n\t    if (style.hasStroke()) {\n\t      // Needs update rect with stroke lineWidth when\n\t      // 1. Element changes scale or lineWidth\n\t      // 2. Shape is changed\n\t      var rectWithStroke = this._rectWithStroke || (this._rectWithStroke = rect.clone());\n\t\n\t      if (this.__dirty || needsUpdateRect) {\n\t        rectWithStroke.copy(rect); // FIXME Must after updateTransform\n\t\n\t        var w = style.lineWidth; // PENDING, Min line width is needed when line is horizontal or vertical\n\t\n\t        var lineScale = style.strokeNoScale ? this.getLineScale() : 1; // Only add extra hover lineWidth when there are no fill\n\t\n\t        if (!style.hasFill()) {\n\t          w = Math.max(w, this.strokeContainThreshold || 4);\n\t        } // Consider line width\n\t        // Line scale can't be 0;\n\t\n\t\n\t        if (lineScale > 1e-10) {\n\t          rectWithStroke.width += w / lineScale;\n\t          rectWithStroke.height += w / lineScale;\n\t          rectWithStroke.x -= w / lineScale / 2;\n\t          rectWithStroke.y -= w / lineScale / 2;\n\t        }\n\t      } // Return rect with stroke\n\t\n\t\n\t      return rectWithStroke;\n\t    }\n\t\n\t    return rect;\n\t  },\n\t  contain: function (x, y) {\n\t    var localPos = this.transformCoordToLocal(x, y);\n\t    var rect = this.getBoundingRect();\n\t    var style = this.style;\n\t    x = localPos[0];\n\t    y = localPos[1];\n\t\n\t    if (rect.contain(x, y)) {\n\t      var pathData = this.path.data;\n\t\n\t      if (style.hasStroke()) {\n\t        var lineWidth = style.lineWidth;\n\t        var lineScale = style.strokeNoScale ? this.getLineScale() : 1; // Line scale can't be 0;\n\t\n\t        if (lineScale > 1e-10) {\n\t          // Only add extra hover lineWidth when there are no fill\n\t          if (!style.hasFill()) {\n\t            lineWidth = Math.max(lineWidth, this.strokeContainThreshold);\n\t          }\n\t\n\t          if (pathContain.containStroke(pathData, lineWidth / lineScale, x, y)) {\n\t            return true;\n\t          }\n\t        }\n\t      }\n\t\n\t      if (style.hasFill()) {\n\t        return pathContain.contain(pathData, x, y);\n\t      }\n\t    }\n\t\n\t    return false;\n\t  },\n\t\n\t  /**\n\t   * @param  {boolean} dirtyPath\n\t   */\n\t  dirty: function (dirtyPath) {\n\t    if (dirtyPath == null) {\n\t      dirtyPath = true;\n\t    } // Only mark dirty, not mark clean\n\t\n\t\n\t    if (dirtyPath) {\n\t      this.__dirtyPath = dirtyPath;\n\t      this._rect = null;\n\t    }\n\t\n\t    this.__dirty = true;\n\t    this.__zr && this.__zr.refresh(); // Used as a clipping path\n\t\n\t    if (this.__clipTarget) {\n\t      this.__clipTarget.dirty();\n\t    }\n\t  },\n\t\n\t  /**\n\t   * Alias for animate('shape')\n\t   * @param {boolean} loop\n\t   */\n\t  animateShape: function (loop) {\n\t    return this.animate('shape', loop);\n\t  },\n\t  // Overwrite attrKV\n\t  attrKV: function (key, value) {\n\t    // FIXME\n\t    if (key === 'shape') {\n\t      this.setShape(value);\n\t      this.__dirtyPath = true;\n\t      this._rect = null;\n\t    } else {\n\t      Displayable.prototype.attrKV.call(this, key, value);\n\t    }\n\t  },\n\t\n\t  /**\n\t   * @param {Object|string} key\n\t   * @param {*} value\n\t   */\n\t  setShape: function (key, value) {\n\t    var shape = this.shape; // Path from string may not have shape\n\t\n\t    if (shape) {\n\t      if (zrUtil.isObject(key)) {\n\t        for (var name in key) {\n\t          if (key.hasOwnProperty(name)) {\n\t            shape[name] = key[name];\n\t          }\n\t        }\n\t      } else {\n\t        shape[key] = value;\n\t      }\n\t\n\t      this.dirty(true);\n\t    }\n\t\n\t    return this;\n\t  },\n\t  getLineScale: function () {\n\t    var m = this.transform; // Get the line scale.\n\t    // Determinant of `m` means how much the area is enlarged by the\n\t    // transformation. So its square root can be used as a scale factor\n\t    // for width.\n\t\n\t    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\t  }\n\t};\n\t/**\n\t * 扩展一个 Path element, 比如星形，圆等。\n\t * Extend a path element\n\t * @param {Object} props\n\t * @param {string} props.type Path type\n\t * @param {Function} props.init Initialize\n\t * @param {Function} props.buildPath Overwrite buildPath method\n\t * @param {Object} [props.style] Extended default style config\n\t * @param {Object} [props.shape] Extended default shape config\n\t */\n\t\n\tPath.extend = function (defaults) {\n\t  var Sub = function (opts) {\n\t    Path.call(this, opts);\n\t\n\t    if (defaults.style) {\n\t      // Extend default style\n\t      this.style.extendFrom(defaults.style, false);\n\t    } // Extend default shape\n\t\n\t\n\t    var defaultShape = defaults.shape;\n\t\n\t    if (defaultShape) {\n\t      this.shape = this.shape || {};\n\t      var thisShape = this.shape;\n\t\n\t      for (var name in defaultShape) {\n\t        if (!thisShape.hasOwnProperty(name) && defaultShape.hasOwnProperty(name)) {\n\t          thisShape[name] = defaultShape[name];\n\t        }\n\t      }\n\t    }\n\t\n\t    defaults.init && defaults.init.call(this, opts);\n\t  };\n\t\n\t  zrUtil.inherits(Sub, Path); // FIXME 不能 extend position, rotation 等引用对象\n\t\n\t  for (var name in defaults) {\n\t    // Extending prototype values and methods\n\t    if (name !== 'style' && name !== 'shape') {\n\t      Sub.prototype[name] = defaults[name];\n\t    }\n\t  }\n\t\n\t  return Sub;\n\t};\n\t\n\tzrUtil.inherits(Path, Displayable);\n\tvar _default = Path;\n\tmodule.exports = _default;\n\n/***/ },\n/* 3 */\n/***/ function(module, exports) {\n\n\tvar ArrayCtor = typeof Float32Array === 'undefined' ? Array : Float32Array;\n\t/**\n\t * 创建一个向量\n\t * @param {number} [x=0]\n\t * @param {number} [y=0]\n\t * @return {Vector2}\n\t */\n\t\n\tfunction create(x, y) {\n\t  var out = new ArrayCtor(2);\n\t\n\t  if (x == null) {\n\t    x = 0;\n\t  }\n\t\n\t  if (y == null) {\n\t    y = 0;\n\t  }\n\t\n\t  out[0] = x;\n\t  out[1] = y;\n\t  return out;\n\t}\n\t/**\n\t * 复制向量数据\n\t * @param {Vector2} out\n\t * @param {Vector2} v\n\t * @return {Vector2}\n\t */\n\t\n\t\n\tfunction copy(out, v) {\n\t  out[0] = v[0];\n\t  out[1] = v[1];\n\t  return out;\n\t}\n\t/**\n\t * 克隆一个向量\n\t * @param {Vector2} v\n\t * @return {Vector2}\n\t */\n\t\n\t\n\tfunction clone(v) {\n\t  var out = new ArrayCtor(2);\n\t  out[0] = v[0];\n\t  out[1] = v[1];\n\t  return out;\n\t}\n\t/**\n\t * 设置向量的两个项\n\t * @param {Vector2} out\n\t * @param {number} a\n\t * @param {number} b\n\t * @return {Vector2} 结果\n\t */\n\t\n\t\n\tfunction set(out, a, b) {\n\t  out[0] = a;\n\t  out[1] = b;\n\t  return out;\n\t}\n\t/**\n\t * 向量相加\n\t * @param {Vector2} out\n\t * @param {Vector2} v1\n\t * @param {Vector2} v2\n\t */\n\t\n\t\n\tfunction add(out, v1, v2) {\n\t  out[0] = v1[0] + v2[0];\n\t  out[1] = v1[1] + v2[1];\n\t  return out;\n\t}\n\t/**\n\t * 向量缩放后相加\n\t * @param {Vector2} out\n\t * @param {Vector2} v1\n\t * @param {Vector2} v2\n\t * @param {number} a\n\t */\n\t\n\t\n\tfunction scaleAndAdd(out, v1, v2, a) {\n\t  out[0] = v1[0] + v2[0] * a;\n\t  out[1] = v1[1] + v2[1] * a;\n\t  return out;\n\t}\n\t/**\n\t * 向量相减\n\t * @param {Vector2} out\n\t * @param {Vector2} v1\n\t * @param {Vector2} v2\n\t */\n\t\n\t\n\tfunction sub(out, v1, v2) {\n\t  out[0] = v1[0] - v2[0];\n\t  out[1] = v1[1] - v2[1];\n\t  return out;\n\t}\n\t/**\n\t * 向量长度\n\t * @param {Vector2} v\n\t * @return {number}\n\t */\n\t\n\t\n\tfunction len(v) {\n\t  return Math.sqrt(lenSquare(v));\n\t}\n\t\n\tvar length = len; // jshint ignore:line\n\t\n\t/**\n\t * 向量长度平方\n\t * @param {Vector2} v\n\t * @return {number}\n\t */\n\t\n\tfunction lenSquare(v) {\n\t  return v[0] * v[0] + v[1] * v[1];\n\t}\n\t\n\tvar lengthSquare = lenSquare;\n\t/**\n\t * 向量乘法\n\t * @param {Vector2} out\n\t * @param {Vector2} v1\n\t * @param {Vector2} v2\n\t */\n\t\n\tfunction mul(out, v1, v2) {\n\t  out[0] = v1[0] * v2[0];\n\t  out[1] = v1[1] * v2[1];\n\t  return out;\n\t}\n\t/**\n\t * 向量除法\n\t * @param {Vector2} out\n\t * @param {Vector2} v1\n\t * @param {Vector2} v2\n\t */\n\t\n\t\n\tfunction div(out, v1, v2) {\n\t  out[0] = v1[0] / v2[0];\n\t  out[1] = v1[1] / v2[1];\n\t  return out;\n\t}\n\t/**\n\t * 向量点乘\n\t * @param {Vector2} v1\n\t * @param {Vector2} v2\n\t * @return {number}\n\t */\n\t\n\t\n\tfunction dot(v1, v2) {\n\t  return v1[0] * v2[0] + v1[1] * v2[1];\n\t}\n\t/**\n\t * 向量缩放\n\t * @param {Vector2} out\n\t * @param {Vector2} v\n\t * @param {number} s\n\t */\n\t\n\t\n\tfunction scale(out, v, s) {\n\t  out[0] = v[0] * s;\n\t  out[1] = v[1] * s;\n\t  return out;\n\t}\n\t/**\n\t * 向量归一化\n\t * @param {Vector2} out\n\t * @param {Vector2} v\n\t */\n\t\n\t\n\tfunction normalize(out, v) {\n\t  var d = len(v);\n\t\n\t  if (d === 0) {\n\t    out[0] = 0;\n\t    out[1] = 0;\n\t  } else {\n\t    out[0] = v[0] / d;\n\t    out[1] = v[1] / d;\n\t  }\n\t\n\t  return out;\n\t}\n\t/**\n\t * 计算向量间距离\n\t * @param {Vector2} v1\n\t * @param {Vector2} v2\n\t * @return {number}\n\t */\n\t\n\t\n\tfunction distance(v1, v2) {\n\t  return Math.sqrt((v1[0] - v2[0]) * (v1[0] - v2[0]) + (v1[1] - v2[1]) * (v1[1] - v2[1]));\n\t}\n\t\n\tvar dist = distance;\n\t/**\n\t * 向量距离平方\n\t * @param {Vector2} v1\n\t * @param {Vector2} v2\n\t * @return {number}\n\t */\n\t\n\tfunction distanceSquare(v1, v2) {\n\t  return (v1[0] - v2[0]) * (v1[0] - v2[0]) + (v1[1] - v2[1]) * (v1[1] - v2[1]);\n\t}\n\t\n\tvar distSquare = distanceSquare;\n\t/**\n\t * 求负向量\n\t * @param {Vector2} out\n\t * @param {Vector2} v\n\t */\n\t\n\tfunction negate(out, v) {\n\t  out[0] = -v[0];\n\t  out[1] = -v[1];\n\t  return out;\n\t}\n\t/**\n\t * 插值两个点\n\t * @param {Vector2} out\n\t * @param {Vector2} v1\n\t * @param {Vector2} v2\n\t * @param {number} t\n\t */\n\t\n\t\n\tfunction lerp(out, v1, v2, t) {\n\t  out[0] = v1[0] + t * (v2[0] - v1[0]);\n\t  out[1] = v1[1] + t * (v2[1] - v1[1]);\n\t  return out;\n\t}\n\t/**\n\t * 矩阵左乘向量\n\t * @param {Vector2} out\n\t * @param {Vector2} v\n\t * @param {Vector2} m\n\t */\n\t\n\t\n\tfunction applyTransform(out, v, m) {\n\t  var x = v[0];\n\t  var y = v[1];\n\t  out[0] = m[0] * x + m[2] * y + m[4];\n\t  out[1] = m[1] * x + m[3] * y + m[5];\n\t  return out;\n\t}\n\t/**\n\t * 求两个向量最小值\n\t * @param  {Vector2} out\n\t * @param  {Vector2} v1\n\t * @param  {Vector2} v2\n\t */\n\t\n\t\n\tfunction min(out, v1, v2) {\n\t  out[0] = Math.min(v1[0], v2[0]);\n\t  out[1] = Math.min(v1[1], v2[1]);\n\t  return out;\n\t}\n\t/**\n\t * 求两个向量最大值\n\t * @param  {Vector2} out\n\t * @param  {Vector2} v1\n\t * @param  {Vector2} v2\n\t */\n\t\n\t\n\tfunction max(out, v1, v2) {\n\t  out[0] = Math.max(v1[0], v2[0]);\n\t  out[1] = Math.max(v1[1], v2[1]);\n\t  return out;\n\t}\n\t\n\texports.create = create;\n\texports.copy = copy;\n\texports.clone = clone;\n\texports.set = set;\n\texports.add = add;\n\texports.scaleAndAdd = scaleAndAdd;\n\texports.sub = sub;\n\texports.len = len;\n\texports.length = length;\n\texports.lenSquare = lenSquare;\n\texports.lengthSquare = lengthSquare;\n\texports.mul = mul;\n\texports.div = div;\n\texports.dot = dot;\n\texports.scale = scale;\n\texports.normalize = normalize;\n\texports.distance = distance;\n\texports.dist = dist;\n\texports.distanceSquare = distanceSquare;\n\texports.distSquare = distSquare;\n\texports.negate = negate;\n\texports.lerp = lerp;\n\texports.applyTransform = applyTransform;\n\texports.min = min;\n\texports.max = max;\n\n/***/ },\n/* 4 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar vec2 = __webpack_require__(3);\n\t\n\tvar matrix = __webpack_require__(10);\n\t\n\t/**\n\t * @module echarts/core/BoundingRect\n\t */\n\tvar v2ApplyTransform = vec2.applyTransform;\n\tvar mathMin = Math.min;\n\tvar mathMax = Math.max;\n\t/**\n\t * @alias module:echarts/core/BoundingRect\n\t */\n\t\n\tfunction BoundingRect(x, y, width, height) {\n\t  if (width < 0) {\n\t    x = x + width;\n\t    width = -width;\n\t  }\n\t\n\t  if (height < 0) {\n\t    y = y + height;\n\t    height = -height;\n\t  }\n\t  /**\n\t   * @type {number}\n\t   */\n\t\n\t\n\t  this.x = x;\n\t  /**\n\t   * @type {number}\n\t   */\n\t\n\t  this.y = y;\n\t  /**\n\t   * @type {number}\n\t   */\n\t\n\t  this.width = width;\n\t  /**\n\t   * @type {number}\n\t   */\n\t\n\t  this.height = height;\n\t}\n\t\n\tBoundingRect.prototype = {\n\t  constructor: BoundingRect,\n\t\n\t  /**\n\t   * @param {module:echarts/core/BoundingRect} other\n\t   */\n\t  union: function (other) {\n\t    var x = mathMin(other.x, this.x);\n\t    var y = mathMin(other.y, this.y);\n\t    this.width = mathMax(other.x + other.width, this.x + this.width) - x;\n\t    this.height = mathMax(other.y + other.height, this.y + this.height) - y;\n\t    this.x = x;\n\t    this.y = y;\n\t  },\n\t\n\t  /**\n\t   * @param {Array.<number>} m\n\t   * @methods\n\t   */\n\t  applyTransform: function () {\n\t    var lt = [];\n\t    var rb = [];\n\t    var lb = [];\n\t    var rt = [];\n\t    return function (m) {\n\t      // In case usage like this\n\t      // el.getBoundingRect().applyTransform(el.transform)\n\t      // And element has no transform\n\t      if (!m) {\n\t        return;\n\t      }\n\t\n\t      lt[0] = lb[0] = this.x;\n\t      lt[1] = rt[1] = this.y;\n\t      rb[0] = rt[0] = this.x + this.width;\n\t      rb[1] = lb[1] = this.y + this.height;\n\t      v2ApplyTransform(lt, lt, m);\n\t      v2ApplyTransform(rb, rb, m);\n\t      v2ApplyTransform(lb, lb, m);\n\t      v2ApplyTransform(rt, rt, m);\n\t      this.x = mathMin(lt[0], rb[0], lb[0], rt[0]);\n\t      this.y = mathMin(lt[1], rb[1], lb[1], rt[1]);\n\t      var maxX = mathMax(lt[0], rb[0], lb[0], rt[0]);\n\t      var maxY = mathMax(lt[1], rb[1], lb[1], rt[1]);\n\t      this.width = maxX - this.x;\n\t      this.height = maxY - this.y;\n\t    };\n\t  }(),\n\t\n\t  /**\n\t   * Calculate matrix of transforming from self to target rect\n\t   * @param  {module:zrender/core/BoundingRect} b\n\t   * @return {Array.<number>}\n\t   */\n\t  calculateTransform: function (b) {\n\t    var a = this;\n\t    var sx = b.width / a.width;\n\t    var sy = b.height / a.height;\n\t    var m = matrix.create(); // 矩阵右乘\n\t\n\t    matrix.translate(m, m, [-a.x, -a.y]);\n\t    matrix.scale(m, m, [sx, sy]);\n\t    matrix.translate(m, m, [b.x, b.y]);\n\t    return m;\n\t  },\n\t\n\t  /**\n\t   * @param {(module:echarts/core/BoundingRect|Object)} b\n\t   * @return {boolean}\n\t   */\n\t  intersect: function (b) {\n\t    if (!b) {\n\t      return false;\n\t    }\n\t\n\t    if (!(b instanceof BoundingRect)) {\n\t      // Normalize negative width/height.\n\t      b = BoundingRect.create(b);\n\t    }\n\t\n\t    var a = this;\n\t    var ax0 = a.x;\n\t    var ax1 = a.x + a.width;\n\t    var ay0 = a.y;\n\t    var ay1 = a.y + a.height;\n\t    var bx0 = b.x;\n\t    var bx1 = b.x + b.width;\n\t    var by0 = b.y;\n\t    var by1 = b.y + b.height;\n\t    return !(ax1 < bx0 || bx1 < ax0 || ay1 < by0 || by1 < ay0);\n\t  },\n\t  contain: function (x, y) {\n\t    var rect = this;\n\t    return x >= rect.x && x <= rect.x + rect.width && y >= rect.y && y <= rect.y + rect.height;\n\t  },\n\t\n\t  /**\n\t   * @return {module:echarts/core/BoundingRect}\n\t   */\n\t  clone: function () {\n\t    return new BoundingRect(this.x, this.y, this.width, this.height);\n\t  },\n\t\n\t  /**\n\t   * Copy from another rect\n\t   */\n\t  copy: function (other) {\n\t    this.x = other.x;\n\t    this.y = other.y;\n\t    this.width = other.width;\n\t    this.height = other.height;\n\t  },\n\t  plain: function () {\n\t    return {\n\t      x: this.x,\n\t      y: this.y,\n\t      width: this.width,\n\t      height: this.height\n\t    };\n\t  }\n\t};\n\t/**\n\t * @param {Object|module:zrender/core/BoundingRect} rect\n\t * @param {number} rect.x\n\t * @param {number} rect.y\n\t * @param {number} rect.width\n\t * @param {number} rect.height\n\t * @return {module:zrender/core/BoundingRect}\n\t */\n\t\n\tBoundingRect.create = function (rect) {\n\t  return new BoundingRect(rect.x, rect.y, rect.width, rect.height);\n\t};\n\t\n\tvar _default = BoundingRect;\n\tmodule.exports = _default;\n\n/***/ },\n/* 5 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar _vector = __webpack_require__(3);\n\t\n\tvar v2Create = _vector.create;\n\tvar v2DistSquare = _vector.distSquare;\n\t\n\t/**\n\t * 曲线辅助模块\n\t * @module zrender/core/curve\n\t * @author pissang(https://www.github.com/pissang)\n\t */\n\tvar mathPow = Math.pow;\n\tvar mathSqrt = Math.sqrt;\n\tvar EPSILON = 1e-8;\n\tvar EPSILON_NUMERIC = 1e-4;\n\tvar THREE_SQRT = mathSqrt(3);\n\tvar ONE_THIRD = 1 / 3; // 临时变量\n\t\n\tvar _v0 = v2Create();\n\t\n\tvar _v1 = v2Create();\n\t\n\tvar _v2 = v2Create();\n\t\n\tfunction isAroundZero(val) {\n\t  return val > -EPSILON && val < EPSILON;\n\t}\n\t\n\tfunction isNotAroundZero(val) {\n\t  return val > EPSILON || val < -EPSILON;\n\t}\n\t/**\n\t * 计算三次贝塞尔值\n\t * @memberOf module:zrender/core/curve\n\t * @param  {number} p0\n\t * @param  {number} p1\n\t * @param  {number} p2\n\t * @param  {number} p3\n\t * @param  {number} t\n\t * @return {number}\n\t */\n\t\n\t\n\tfunction cubicAt(p0, p1, p2, p3, t) {\n\t  var onet = 1 - t;\n\t  return onet * onet * (onet * p0 + 3 * t * p1) + t * t * (t * p3 + 3 * onet * p2);\n\t}\n\t/**\n\t * 计算三次贝塞尔导数值\n\t * @memberOf module:zrender/core/curve\n\t * @param  {number} p0\n\t * @param  {number} p1\n\t * @param  {number} p2\n\t * @param  {number} p3\n\t * @param  {number} t\n\t * @return {number}\n\t */\n\t\n\t\n\tfunction cubicDerivativeAt(p0, p1, p2, p3, t) {\n\t  var onet = 1 - t;\n\t  return 3 * (((p1 - p0) * onet + 2 * (p2 - p1) * t) * onet + (p3 - p2) * t * t);\n\t}\n\t/**\n\t * 计算三次贝塞尔方程根，使用盛金公式\n\t * @memberOf module:zrender/core/curve\n\t * @param  {number} p0\n\t * @param  {number} p1\n\t * @param  {number} p2\n\t * @param  {number} p3\n\t * @param  {number} val\n\t * @param  {Array.<number>} roots\n\t * @return {number} 有效根数目\n\t */\n\t\n\t\n\tfunction cubicRootAt(p0, p1, p2, p3, val, roots) {\n\t  // Evaluate roots of cubic functions\n\t  var a = p3 + 3 * (p1 - p2) - p0;\n\t  var b = 3 * (p2 - p1 * 2 + p0);\n\t  var c = 3 * (p1 - p0);\n\t  var d = p0 - val;\n\t  var A = b * b - 3 * a * c;\n\t  var B = b * c - 9 * a * d;\n\t  var C = c * c - 3 * b * d;\n\t  var n = 0;\n\t\n\t  if (isAroundZero(A) && isAroundZero(B)) {\n\t    if (isAroundZero(b)) {\n\t      roots[0] = 0;\n\t    } else {\n\t      var t1 = -c / b; //t1, t2, t3, b is not zero\n\t\n\t      if (t1 >= 0 && t1 <= 1) {\n\t        roots[n++] = t1;\n\t      }\n\t    }\n\t  } else {\n\t    var disc = B * B - 4 * A * C;\n\t\n\t    if (isAroundZero(disc)) {\n\t      var K = B / A;\n\t      var t1 = -b / a + K; // t1, a is not zero\n\t\n\t      var t2 = -K / 2; // t2, t3\n\t\n\t      if (t1 >= 0 && t1 <= 1) {\n\t        roots[n++] = t1;\n\t      }\n\t\n\t      if (t2 >= 0 && t2 <= 1) {\n\t        roots[n++] = t2;\n\t      }\n\t    } else if (disc > 0) {\n\t      var discSqrt = mathSqrt(disc);\n\t      var Y1 = A * b + 1.5 * a * (-B + discSqrt);\n\t      var Y2 = A * b + 1.5 * a * (-B - discSqrt);\n\t\n\t      if (Y1 < 0) {\n\t        Y1 = -mathPow(-Y1, ONE_THIRD);\n\t      } else {\n\t        Y1 = mathPow(Y1, ONE_THIRD);\n\t      }\n\t\n\t      if (Y2 < 0) {\n\t        Y2 = -mathPow(-Y2, ONE_THIRD);\n\t      } else {\n\t        Y2 = mathPow(Y2, ONE_THIRD);\n\t      }\n\t\n\t      var t1 = (-b - (Y1 + Y2)) / (3 * a);\n\t\n\t      if (t1 >= 0 && t1 <= 1) {\n\t        roots[n++] = t1;\n\t      }\n\t    } else {\n\t      var T = (2 * A * b - 3 * a * B) / (2 * mathSqrt(A * A * A));\n\t      var theta = Math.acos(T) / 3;\n\t      var ASqrt = mathSqrt(A);\n\t      var tmp = Math.cos(theta);\n\t      var t1 = (-b - 2 * ASqrt * tmp) / (3 * a);\n\t      var t2 = (-b + ASqrt * (tmp + THREE_SQRT * Math.sin(theta))) / (3 * a);\n\t      var t3 = (-b + ASqrt * (tmp - THREE_SQRT * Math.sin(theta))) / (3 * a);\n\t\n\t      if (t1 >= 0 && t1 <= 1) {\n\t        roots[n++] = t1;\n\t      }\n\t\n\t      if (t2 >= 0 && t2 <= 1) {\n\t        roots[n++] = t2;\n\t      }\n\t\n\t      if (t3 >= 0 && t3 <= 1) {\n\t        roots[n++] = t3;\n\t      }\n\t    }\n\t  }\n\t\n\t  return n;\n\t}\n\t/**\n\t * 计算三次贝塞尔方程极限值的位置\n\t * @memberOf module:zrender/core/curve\n\t * @param  {number} p0\n\t * @param  {number} p1\n\t * @param  {number} p2\n\t * @param  {number} p3\n\t * @param  {Array.<number>} extrema\n\t * @return {number} 有效数目\n\t */\n\t\n\t\n\tfunction cubicExtrema(p0, p1, p2, p3, extrema) {\n\t  var b = 6 * p2 - 12 * p1 + 6 * p0;\n\t  var a = 9 * p1 + 3 * p3 - 3 * p0 - 9 * p2;\n\t  var c = 3 * p1 - 3 * p0;\n\t  var n = 0;\n\t\n\t  if (isAroundZero(a)) {\n\t    if (isNotAroundZero(b)) {\n\t      var t1 = -c / b;\n\t\n\t      if (t1 >= 0 && t1 <= 1) {\n\t        extrema[n++] = t1;\n\t      }\n\t    }\n\t  } else {\n\t    var disc = b * b - 4 * a * c;\n\t\n\t    if (isAroundZero(disc)) {\n\t      extrema[0] = -b / (2 * a);\n\t    } else if (disc > 0) {\n\t      var discSqrt = mathSqrt(disc);\n\t      var t1 = (-b + discSqrt) / (2 * a);\n\t      var t2 = (-b - discSqrt) / (2 * a);\n\t\n\t      if (t1 >= 0 && t1 <= 1) {\n\t        extrema[n++] = t1;\n\t      }\n\t\n\t      if (t2 >= 0 && t2 <= 1) {\n\t        extrema[n++] = t2;\n\t      }\n\t    }\n\t  }\n\t\n\t  return n;\n\t}\n\t/**\n\t * 细分三次贝塞尔曲线\n\t * @memberOf module:zrender/core/curve\n\t * @param  {number} p0\n\t * @param  {number} p1\n\t * @param  {number} p2\n\t * @param  {number} p3\n\t * @param  {number} t\n\t * @param  {Array.<number>} out\n\t */\n\t\n\t\n\tfunction cubicSubdivide(p0, p1, p2, p3, t, out) {\n\t  var p01 = (p1 - p0) * t + p0;\n\t  var p12 = (p2 - p1) * t + p1;\n\t  var p23 = (p3 - p2) * t + p2;\n\t  var p012 = (p12 - p01) * t + p01;\n\t  var p123 = (p23 - p12) * t + p12;\n\t  var p0123 = (p123 - p012) * t + p012; // Seg0\n\t\n\t  out[0] = p0;\n\t  out[1] = p01;\n\t  out[2] = p012;\n\t  out[3] = p0123; // Seg1\n\t\n\t  out[4] = p0123;\n\t  out[5] = p123;\n\t  out[6] = p23;\n\t  out[7] = p3;\n\t}\n\t/**\n\t * 投射点到三次贝塞尔曲线上，返回投射距离。\n\t * 投射点有可能会有一个或者多个，这里只返回其中距离最短的一个。\n\t * @param {number} x0\n\t * @param {number} y0\n\t * @param {number} x1\n\t * @param {number} y1\n\t * @param {number} x2\n\t * @param {number} y2\n\t * @param {number} x3\n\t * @param {number} y3\n\t * @param {number} x\n\t * @param {number} y\n\t * @param {Array.<number>} [out] 投射点\n\t * @return {number}\n\t */\n\t\n\t\n\tfunction cubicProjectPoint(x0, y0, x1, y1, x2, y2, x3, y3, x, y, out) {\n\t  // http://pomax.github.io/bezierinfo/#projections\n\t  var t;\n\t  var interval = 0.005;\n\t  var d = Infinity;\n\t  var prev;\n\t  var next;\n\t  var d1;\n\t  var d2;\n\t  _v0[0] = x;\n\t  _v0[1] = y; // 先粗略估计一下可能的最小距离的 t 值\n\t  // PENDING\n\t\n\t  for (var _t = 0; _t < 1; _t += 0.05) {\n\t    _v1[0] = cubicAt(x0, x1, x2, x3, _t);\n\t    _v1[1] = cubicAt(y0, y1, y2, y3, _t);\n\t    d1 = v2DistSquare(_v0, _v1);\n\t\n\t    if (d1 < d) {\n\t      t = _t;\n\t      d = d1;\n\t    }\n\t  }\n\t\n\t  d = Infinity; // At most 32 iteration\n\t\n\t  for (var i = 0; i < 32; i++) {\n\t    if (interval < EPSILON_NUMERIC) {\n\t      break;\n\t    }\n\t\n\t    prev = t - interval;\n\t    next = t + interval; // t - interval\n\t\n\t    _v1[0] = cubicAt(x0, x1, x2, x3, prev);\n\t    _v1[1] = cubicAt(y0, y1, y2, y3, prev);\n\t    d1 = v2DistSquare(_v1, _v0);\n\t\n\t    if (prev >= 0 && d1 < d) {\n\t      t = prev;\n\t      d = d1;\n\t    } else {\n\t      // t + interval\n\t      _v2[0] = cubicAt(x0, x1, x2, x3, next);\n\t      _v2[1] = cubicAt(y0, y1, y2, y3, next);\n\t      d2 = v2DistSquare(_v2, _v0);\n\t\n\t      if (next <= 1 && d2 < d) {\n\t        t = next;\n\t        d = d2;\n\t      } else {\n\t        interval *= 0.5;\n\t      }\n\t    }\n\t  } // t\n\t\n\t\n\t  if (out) {\n\t    out[0] = cubicAt(x0, x1, x2, x3, t);\n\t    out[1] = cubicAt(y0, y1, y2, y3, t);\n\t  } // console.log(interval, i);\n\t\n\t\n\t  return mathSqrt(d);\n\t}\n\t/**\n\t * 计算二次方贝塞尔值\n\t * @param  {number} p0\n\t * @param  {number} p1\n\t * @param  {number} p2\n\t * @param  {number} t\n\t * @return {number}\n\t */\n\t\n\t\n\tfunction quadraticAt(p0, p1, p2, t) {\n\t  var onet = 1 - t;\n\t  return onet * (onet * p0 + 2 * t * p1) + t * t * p2;\n\t}\n\t/**\n\t * 计算二次方贝塞尔导数值\n\t * @param  {number} p0\n\t * @param  {number} p1\n\t * @param  {number} p2\n\t * @param  {number} t\n\t * @return {number}\n\t */\n\t\n\t\n\tfunction quadraticDerivativeAt(p0, p1, p2, t) {\n\t  return 2 * ((1 - t) * (p1 - p0) + t * (p2 - p1));\n\t}\n\t/**\n\t * 计算二次方贝塞尔方程根\n\t * @param  {number} p0\n\t * @param  {number} p1\n\t * @param  {number} p2\n\t * @param  {number} t\n\t * @param  {Array.<number>} roots\n\t * @return {number} 有效根数目\n\t */\n\t\n\t\n\tfunction quadraticRootAt(p0, p1, p2, val, roots) {\n\t  var a = p0 - 2 * p1 + p2;\n\t  var b = 2 * (p1 - p0);\n\t  var c = p0 - val;\n\t  var n = 0;\n\t\n\t  if (isAroundZero(a)) {\n\t    if (isNotAroundZero(b)) {\n\t      var t1 = -c / b;\n\t\n\t      if (t1 >= 0 && t1 <= 1) {\n\t        roots[n++] = t1;\n\t      }\n\t    }\n\t  } else {\n\t    var disc = b * b - 4 * a * c;\n\t\n\t    if (isAroundZero(disc)) {\n\t      var t1 = -b / (2 * a);\n\t\n\t      if (t1 >= 0 && t1 <= 1) {\n\t        roots[n++] = t1;\n\t      }\n\t    } else if (disc > 0) {\n\t      var discSqrt = mathSqrt(disc);\n\t      var t1 = (-b + discSqrt) / (2 * a);\n\t      var t2 = (-b - discSqrt) / (2 * a);\n\t\n\t      if (t1 >= 0 && t1 <= 1) {\n\t        roots[n++] = t1;\n\t      }\n\t\n\t      if (t2 >= 0 && t2 <= 1) {\n\t        roots[n++] = t2;\n\t      }\n\t    }\n\t  }\n\t\n\t  return n;\n\t}\n\t/**\n\t * 计算二次贝塞尔方程极限值\n\t * @memberOf module:zrender/core/curve\n\t * @param  {number} p0\n\t * @param  {number} p1\n\t * @param  {number} p2\n\t * @return {number}\n\t */\n\t\n\t\n\tfunction quadraticExtremum(p0, p1, p2) {\n\t  var divider = p0 + p2 - 2 * p1;\n\t\n\t  if (divider === 0) {\n\t    // p1 is center of p0 and p2\n\t    return 0.5;\n\t  } else {\n\t    return (p0 - p1) / divider;\n\t  }\n\t}\n\t/**\n\t * 细分二次贝塞尔曲线\n\t * @memberOf module:zrender/core/curve\n\t * @param  {number} p0\n\t * @param  {number} p1\n\t * @param  {number} p2\n\t * @param  {number} t\n\t * @param  {Array.<number>} out\n\t */\n\t\n\t\n\tfunction quadraticSubdivide(p0, p1, p2, t, out) {\n\t  var p01 = (p1 - p0) * t + p0;\n\t  var p12 = (p2 - p1) * t + p1;\n\t  var p012 = (p12 - p01) * t + p01; // Seg0\n\t\n\t  out[0] = p0;\n\t  out[1] = p01;\n\t  out[2] = p012; // Seg1\n\t\n\t  out[3] = p012;\n\t  out[4] = p12;\n\t  out[5] = p2;\n\t}\n\t/**\n\t * 投射点到二次贝塞尔曲线上，返回投射距离。\n\t * 投射点有可能会有一个或者多个，这里只返回其中距离最短的一个。\n\t * @param {number} x0\n\t * @param {number} y0\n\t * @param {number} x1\n\t * @param {number} y1\n\t * @param {number} x2\n\t * @param {number} y2\n\t * @param {number} x\n\t * @param {number} y\n\t * @param {Array.<number>} out 投射点\n\t * @return {number}\n\t */\n\t\n\t\n\tfunction quadraticProjectPoint(x0, y0, x1, y1, x2, y2, x, y, out) {\n\t  // http://pomax.github.io/bezierinfo/#projections\n\t  var t;\n\t  var interval = 0.005;\n\t  var d = Infinity;\n\t  _v0[0] = x;\n\t  _v0[1] = y; // 先粗略估计一下可能的最小距离的 t 值\n\t  // PENDING\n\t\n\t  for (var _t = 0; _t < 1; _t += 0.05) {\n\t    _v1[0] = quadraticAt(x0, x1, x2, _t);\n\t    _v1[1] = quadraticAt(y0, y1, y2, _t);\n\t    var d1 = v2DistSquare(_v0, _v1);\n\t\n\t    if (d1 < d) {\n\t      t = _t;\n\t      d = d1;\n\t    }\n\t  }\n\t\n\t  d = Infinity; // At most 32 iteration\n\t\n\t  for (var i = 0; i < 32; i++) {\n\t    if (interval < EPSILON_NUMERIC) {\n\t      break;\n\t    }\n\t\n\t    var prev = t - interval;\n\t    var next = t + interval; // t - interval\n\t\n\t    _v1[0] = quadraticAt(x0, x1, x2, prev);\n\t    _v1[1] = quadraticAt(y0, y1, y2, prev);\n\t    var d1 = v2DistSquare(_v1, _v0);\n\t\n\t    if (prev >= 0 && d1 < d) {\n\t      t = prev;\n\t      d = d1;\n\t    } else {\n\t      // t + interval\n\t      _v2[0] = quadraticAt(x0, x1, x2, next);\n\t      _v2[1] = quadraticAt(y0, y1, y2, next);\n\t      var d2 = v2DistSquare(_v2, _v0);\n\t\n\t      if (next <= 1 && d2 < d) {\n\t        t = next;\n\t        d = d2;\n\t      } else {\n\t        interval *= 0.5;\n\t      }\n\t    }\n\t  } // t\n\t\n\t\n\t  if (out) {\n\t    out[0] = quadraticAt(x0, x1, x2, t);\n\t    out[1] = quadraticAt(y0, y1, y2, t);\n\t  } // console.log(interval, i);\n\t\n\t\n\t  return mathSqrt(d);\n\t}\n\t\n\texports.cubicAt = cubicAt;\n\texports.cubicDerivativeAt = cubicDerivativeAt;\n\texports.cubicRootAt = cubicRootAt;\n\texports.cubicExtrema = cubicExtrema;\n\texports.cubicSubdivide = cubicSubdivide;\n\texports.cubicProjectPoint = cubicProjectPoint;\n\texports.quadraticAt = quadraticAt;\n\texports.quadraticDerivativeAt = quadraticDerivativeAt;\n\texports.quadraticRootAt = quadraticRootAt;\n\texports.quadraticExtremum = quadraticExtremum;\n\texports.quadraticSubdivide = quadraticSubdivide;\n\texports.quadraticProjectPoint = quadraticProjectPoint;\n\n/***/ },\n/* 6 */\n/***/ function(module, exports) {\n\n\t/* WEBPACK VAR INJECTION */(function(global) {// (1) The code `if (__DEV__) ...` can be removed by build tool.\n\t// (2) If intend to use `__DEV__`, this module should be imported. Use a global\n\t// variable `__DEV__` may cause that miss the declaration (see #6535), or the\n\t// declaration is behind of the using position (for example in `Model.extent`,\n\t// And tools like rollup can not analysis the dependency if not import).\n\tvar dev; // In browser\n\t\n\tif (typeof window !== 'undefined') {\n\t  dev = window.__DEV__;\n\t} // In node\n\telse if (typeof global !== 'undefined') {\n\t    dev = global.__DEV__;\n\t  }\n\t\n\tif (typeof dev === 'undefined') {\n\t  dev = true;\n\t}\n\t\n\tvar __DEV__ = dev;\n\texports.__DEV__ = __DEV__;\n\t/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))\n\n/***/ },\n/* 7 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar curve = __webpack_require__(5);\n\t\n\tvar vec2 = __webpack_require__(3);\n\t\n\tvar bbox = __webpack_require__(45);\n\t\n\tvar BoundingRect = __webpack_require__(4);\n\t\n\tvar _config = __webpack_require__(16);\n\t\n\tvar dpr = _config.devicePixelRatio;\n\t\n\t/**\n\t * Path 代理，可以在`buildPath`中用于替代`ctx`, 会保存每个path操作的命令到pathCommands属性中\n\t * 可以用于 isInsidePath 判断以及获取boundingRect\n\t *\n\t * @module zrender/core/PathProxy\n\t * @author Yi Shen (http://www.github.com/pissang)\n\t */\n\t// TODO getTotalLength, getPointAtLength\n\tvar CMD = {\n\t  M: 1,\n\t  L: 2,\n\t  C: 3,\n\t  Q: 4,\n\t  A: 5,\n\t  Z: 6,\n\t  // Rect\n\t  R: 7\n\t}; // var CMD_MEM_SIZE = {\n\t//     M: 3,\n\t//     L: 3,\n\t//     C: 7,\n\t//     Q: 5,\n\t//     A: 9,\n\t//     R: 5,\n\t//     Z: 1\n\t// };\n\t\n\tvar min = [];\n\tvar max = [];\n\tvar min2 = [];\n\tvar max2 = [];\n\tvar mathMin = Math.min;\n\tvar mathMax = Math.max;\n\tvar mathCos = Math.cos;\n\tvar mathSin = Math.sin;\n\tvar mathSqrt = Math.sqrt;\n\tvar mathAbs = Math.abs;\n\tvar hasTypedArray = typeof Float32Array != 'undefined';\n\t/**\n\t * @alias module:zrender/core/PathProxy\n\t * @constructor\n\t */\n\t\n\tvar PathProxy = function (notSaveData) {\n\t  this._saveData = !(notSaveData || false);\n\t\n\t  if (this._saveData) {\n\t    /**\n\t     * Path data. Stored as flat array\n\t     * @type {Array.<Object>}\n\t     */\n\t    this.data = [];\n\t  }\n\t\n\t  this._ctx = null;\n\t};\n\t/**\n\t * 快速计算Path包围盒（并不是最小包围盒）\n\t * @return {Object}\n\t */\n\t\n\t\n\tPathProxy.prototype = {\n\t  constructor: PathProxy,\n\t  _xi: 0,\n\t  _yi: 0,\n\t  _x0: 0,\n\t  _y0: 0,\n\t  // Unit x, Unit y. Provide for avoiding drawing that too short line segment\n\t  _ux: 0,\n\t  _uy: 0,\n\t  _len: 0,\n\t  _lineDash: null,\n\t  _dashOffset: 0,\n\t  _dashIdx: 0,\n\t  _dashSum: 0,\n\t\n\t  /**\n\t   * @readOnly\n\t   */\n\t  setScale: function (sx, sy) {\n\t    this._ux = mathAbs(1 / dpr / sx) || 0;\n\t    this._uy = mathAbs(1 / dpr / sy) || 0;\n\t  },\n\t  getContext: function () {\n\t    return this._ctx;\n\t  },\n\t\n\t  /**\n\t   * @param  {CanvasRenderingContext2D} ctx\n\t   * @return {module:zrender/core/PathProxy}\n\t   */\n\t  beginPath: function (ctx) {\n\t    this._ctx = ctx;\n\t    ctx && ctx.beginPath();\n\t    ctx && (this.dpr = ctx.dpr); // Reset\n\t\n\t    if (this._saveData) {\n\t      this._len = 0;\n\t    }\n\t\n\t    if (this._lineDash) {\n\t      this._lineDash = null;\n\t      this._dashOffset = 0;\n\t    }\n\t\n\t    return this;\n\t  },\n\t\n\t  /**\n\t   * @param  {number} x\n\t   * @param  {number} y\n\t   * @return {module:zrender/core/PathProxy}\n\t   */\n\t  moveTo: function (x, y) {\n\t    this.addData(CMD.M, x, y);\n\t    this._ctx && this._ctx.moveTo(x, y); // x0, y0, xi, yi 是记录在 _dashedXXXXTo 方法中使用\n\t    // xi, yi 记录当前点, x0, y0 在 closePath 的时候回到起始点。\n\t    // 有可能在 beginPath 之后直接调用 lineTo，这时候 x0, y0 需要\n\t    // 在 lineTo 方法中记录，这里先不考虑这种情况，dashed line 也只在 IE10- 中不支持\n\t\n\t    this._x0 = x;\n\t    this._y0 = y;\n\t    this._xi = x;\n\t    this._yi = y;\n\t    return this;\n\t  },\n\t\n\t  /**\n\t   * @param  {number} x\n\t   * @param  {number} y\n\t   * @return {module:zrender/core/PathProxy}\n\t   */\n\t  lineTo: function (x, y) {\n\t    var exceedUnit = mathAbs(x - this._xi) > this._ux || mathAbs(y - this._yi) > this._uy // Force draw the first segment\n\t    || this._len < 5;\n\t    this.addData(CMD.L, x, y);\n\t\n\t    if (this._ctx && exceedUnit) {\n\t      this._needsDash() ? this._dashedLineTo(x, y) : this._ctx.lineTo(x, y);\n\t    }\n\t\n\t    if (exceedUnit) {\n\t      this._xi = x;\n\t      this._yi = y;\n\t    }\n\t\n\t    return this;\n\t  },\n\t\n\t  /**\n\t   * @param  {number} x1\n\t   * @param  {number} y1\n\t   * @param  {number} x2\n\t   * @param  {number} y2\n\t   * @param  {number} x3\n\t   * @param  {number} y3\n\t   * @return {module:zrender/core/PathProxy}\n\t   */\n\t  bezierCurveTo: function (x1, y1, x2, y2, x3, y3) {\n\t    this.addData(CMD.C, x1, y1, x2, y2, x3, y3);\n\t\n\t    if (this._ctx) {\n\t      this._needsDash() ? this._dashedBezierTo(x1, y1, x2, y2, x3, y3) : this._ctx.bezierCurveTo(x1, y1, x2, y2, x3, y3);\n\t    }\n\t\n\t    this._xi = x3;\n\t    this._yi = y3;\n\t    return this;\n\t  },\n\t\n\t  /**\n\t   * @param  {number} x1\n\t   * @param  {number} y1\n\t   * @param  {number} x2\n\t   * @param  {number} y2\n\t   * @return {module:zrender/core/PathProxy}\n\t   */\n\t  quadraticCurveTo: function (x1, y1, x2, y2) {\n\t    this.addData(CMD.Q, x1, y1, x2, y2);\n\t\n\t    if (this._ctx) {\n\t      this._needsDash() ? this._dashedQuadraticTo(x1, y1, x2, y2) : this._ctx.quadraticCurveTo(x1, y1, x2, y2);\n\t    }\n\t\n\t    this._xi = x2;\n\t    this._yi = y2;\n\t    return this;\n\t  },\n\t\n\t  /**\n\t   * @param  {number} cx\n\t   * @param  {number} cy\n\t   * @param  {number} r\n\t   * @param  {number} startAngle\n\t   * @param  {number} endAngle\n\t   * @param  {boolean} anticlockwise\n\t   * @return {module:zrender/core/PathProxy}\n\t   */\n\t  arc: function (cx, cy, r, startAngle, endAngle, anticlockwise) {\n\t    this.addData(CMD.A, cx, cy, r, r, startAngle, endAngle - startAngle, 0, anticlockwise ? 0 : 1);\n\t    this._ctx && this._ctx.arc(cx, cy, r, startAngle, endAngle, anticlockwise);\n\t    this._xi = mathCos(endAngle) * r + cx;\n\t    this._yi = mathSin(endAngle) * r + cx;\n\t    return this;\n\t  },\n\t  // TODO\n\t  arcTo: function (x1, y1, x2, y2, radius) {\n\t    if (this._ctx) {\n\t      this._ctx.arcTo(x1, y1, x2, y2, radius);\n\t    }\n\t\n\t    return this;\n\t  },\n\t  // TODO\n\t  rect: function (x, y, w, h) {\n\t    this._ctx && this._ctx.rect(x, y, w, h);\n\t    this.addData(CMD.R, x, y, w, h);\n\t    return this;\n\t  },\n\t\n\t  /**\n\t   * @return {module:zrender/core/PathProxy}\n\t   */\n\t  closePath: function () {\n\t    this.addData(CMD.Z);\n\t    var ctx = this._ctx;\n\t    var x0 = this._x0;\n\t    var y0 = this._y0;\n\t\n\t    if (ctx) {\n\t      this._needsDash() && this._dashedLineTo(x0, y0);\n\t      ctx.closePath();\n\t    }\n\t\n\t    this._xi = x0;\n\t    this._yi = y0;\n\t    return this;\n\t  },\n\t\n\t  /**\n\t   * Context 从外部传入，因为有可能是 rebuildPath 完之后再 fill。\n\t   * stroke 同样\n\t   * @param {CanvasRenderingContext2D} ctx\n\t   * @return {module:zrender/core/PathProxy}\n\t   */\n\t  fill: function (ctx) {\n\t    ctx && ctx.fill();\n\t    this.toStatic();\n\t  },\n\t\n\t  /**\n\t   * @param {CanvasRenderingContext2D} ctx\n\t   * @return {module:zrender/core/PathProxy}\n\t   */\n\t  stroke: function (ctx) {\n\t    ctx && ctx.stroke();\n\t    this.toStatic();\n\t  },\n\t\n\t  /**\n\t   * 必须在其它绘制命令前调用\n\t   * Must be invoked before all other path drawing methods\n\t   * @return {module:zrender/core/PathProxy}\n\t   */\n\t  setLineDash: function (lineDash) {\n\t    if (lineDash instanceof Array) {\n\t      this._lineDash = lineDash;\n\t      this._dashIdx = 0;\n\t      var lineDashSum = 0;\n\t\n\t      for (var i = 0; i < lineDash.length; i++) {\n\t        lineDashSum += lineDash[i];\n\t      }\n\t\n\t      this._dashSum = lineDashSum;\n\t    }\n\t\n\t    return this;\n\t  },\n\t\n\t  /**\n\t   * 必须在其它绘制命令前调用\n\t   * Must be invoked before all other path drawing methods\n\t   * @return {module:zrender/core/PathProxy}\n\t   */\n\t  setLineDashOffset: function (offset) {\n\t    this._dashOffset = offset;\n\t    return this;\n\t  },\n\t\n\t  /**\n\t   *\n\t   * @return {boolean}\n\t   */\n\t  len: function () {\n\t    return this._len;\n\t  },\n\t\n\t  /**\n\t   * 直接设置 Path 数据\n\t   */\n\t  setData: function (data) {\n\t    var len = data.length;\n\t\n\t    if (!(this.data && this.data.length == len) && hasTypedArray) {\n\t      this.data = new Float32Array(len);\n\t    }\n\t\n\t    for (var i = 0; i < len; i++) {\n\t      this.data[i] = data[i];\n\t    }\n\t\n\t    this._len = len;\n\t  },\n\t\n\t  /**\n\t   * 添加子路径\n\t   * @param {module:zrender/core/PathProxy|Array.<module:zrender/core/PathProxy>} path\n\t   */\n\t  appendPath: function (path) {\n\t    if (!(path instanceof Array)) {\n\t      path = [path];\n\t    }\n\t\n\t    var len = path.length;\n\t    var appendSize = 0;\n\t    var offset = this._len;\n\t\n\t    for (var i = 0; i < len; i++) {\n\t      appendSize += path[i].len();\n\t    }\n\t\n\t    if (hasTypedArray && this.data instanceof Float32Array) {\n\t      this.data = new Float32Array(offset + appendSize);\n\t    }\n\t\n\t    for (var i = 0; i < len; i++) {\n\t      var appendPathData = path[i].data;\n\t\n\t      for (var k = 0; k < appendPathData.length; k++) {\n\t        this.data[offset++] = appendPathData[k];\n\t      }\n\t    }\n\t\n\t    this._len = offset;\n\t  },\n\t\n\t  /**\n\t   * 填充 Path 数据。\n\t   * 尽量复用而不申明新的数组。大部分图形重绘的指令数据长度都是不变的。\n\t   */\n\t  addData: function (cmd) {\n\t    if (!this._saveData) {\n\t      return;\n\t    }\n\t\n\t    var data = this.data;\n\t\n\t    if (this._len + arguments.length > data.length) {\n\t      // 因为之前的数组已经转换成静态的 Float32Array\n\t      // 所以不够用时需要扩展一个新的动态数组\n\t      this._expandData();\n\t\n\t      data = this.data;\n\t    }\n\t\n\t    for (var i = 0; i < arguments.length; i++) {\n\t      data[this._len++] = arguments[i];\n\t    }\n\t\n\t    this._prevCmd = cmd;\n\t  },\n\t  _expandData: function () {\n\t    // Only if data is Float32Array\n\t    if (!(this.data instanceof Array)) {\n\t      var newData = [];\n\t\n\t      for (var i = 0; i < this._len; i++) {\n\t        newData[i] = this.data[i];\n\t      }\n\t\n\t      this.data = newData;\n\t    }\n\t  },\n\t\n\t  /**\n\t   * If needs js implemented dashed line\n\t   * @return {boolean}\n\t   * @private\n\t   */\n\t  _needsDash: function () {\n\t    return this._lineDash;\n\t  },\n\t  _dashedLineTo: function (x1, y1) {\n\t    var dashSum = this._dashSum;\n\t    var offset = this._dashOffset;\n\t    var lineDash = this._lineDash;\n\t    var ctx = this._ctx;\n\t    var x0 = this._xi;\n\t    var y0 = this._yi;\n\t    var dx = x1 - x0;\n\t    var dy = y1 - y0;\n\t    var dist = mathSqrt(dx * dx + dy * dy);\n\t    var x = x0;\n\t    var y = y0;\n\t    var dash;\n\t    var nDash = lineDash.length;\n\t    var idx;\n\t    dx /= dist;\n\t    dy /= dist;\n\t\n\t    if (offset < 0) {\n\t      // Convert to positive offset\n\t      offset = dashSum + offset;\n\t    }\n\t\n\t    offset %= dashSum;\n\t    x -= offset * dx;\n\t    y -= offset * dy;\n\t\n\t    while (dx > 0 && x <= x1 || dx < 0 && x >= x1 || dx == 0 && (dy > 0 && y <= y1 || dy < 0 && y >= y1)) {\n\t      idx = this._dashIdx;\n\t      dash = lineDash[idx];\n\t      x += dx * dash;\n\t      y += dy * dash;\n\t      this._dashIdx = (idx + 1) % nDash; // Skip positive offset\n\t\n\t      if (dx > 0 && x < x0 || dx < 0 && x > x0 || dy > 0 && y < y0 || dy < 0 && y > y0) {\n\t        continue;\n\t      }\n\t\n\t      ctx[idx % 2 ? 'moveTo' : 'lineTo'](dx >= 0 ? mathMin(x, x1) : mathMax(x, x1), dy >= 0 ? mathMin(y, y1) : mathMax(y, y1));\n\t    } // Offset for next lineTo\n\t\n\t\n\t    dx = x - x1;\n\t    dy = y - y1;\n\t    this._dashOffset = -mathSqrt(dx * dx + dy * dy);\n\t  },\n\t  // Not accurate dashed line to\n\t  _dashedBezierTo: function (x1, y1, x2, y2, x3, y3) {\n\t    var dashSum = this._dashSum;\n\t    var offset = this._dashOffset;\n\t    var lineDash = this._lineDash;\n\t    var ctx = this._ctx;\n\t    var x0 = this._xi;\n\t    var y0 = this._yi;\n\t    var t;\n\t    var dx;\n\t    var dy;\n\t    var cubicAt = curve.cubicAt;\n\t    var bezierLen = 0;\n\t    var idx = this._dashIdx;\n\t    var nDash = lineDash.length;\n\t    var x;\n\t    var y;\n\t    var tmpLen = 0;\n\t\n\t    if (offset < 0) {\n\t      // Convert to positive offset\n\t      offset = dashSum + offset;\n\t    }\n\t\n\t    offset %= dashSum; // Bezier approx length\n\t\n\t    for (t = 0; t < 1; t += 0.1) {\n\t      dx = cubicAt(x0, x1, x2, x3, t + 0.1) - cubicAt(x0, x1, x2, x3, t);\n\t      dy = cubicAt(y0, y1, y2, y3, t + 0.1) - cubicAt(y0, y1, y2, y3, t);\n\t      bezierLen += mathSqrt(dx * dx + dy * dy);\n\t    } // Find idx after add offset\n\t\n\t\n\t    for (; idx < nDash; idx++) {\n\t      tmpLen += lineDash[idx];\n\t\n\t      if (tmpLen > offset) {\n\t        break;\n\t      }\n\t    }\n\t\n\t    t = (tmpLen - offset) / bezierLen;\n\t\n\t    while (t <= 1) {\n\t      x = cubicAt(x0, x1, x2, x3, t);\n\t      y = cubicAt(y0, y1, y2, y3, t); // Use line to approximate dashed bezier\n\t      // Bad result if dash is long\n\t\n\t      idx % 2 ? ctx.moveTo(x, y) : ctx.lineTo(x, y);\n\t      t += lineDash[idx] / bezierLen;\n\t      idx = (idx + 1) % nDash;\n\t    } // Finish the last segment and calculate the new offset\n\t\n\t\n\t    idx % 2 !== 0 && ctx.lineTo(x3, y3);\n\t    dx = x3 - x;\n\t    dy = y3 - y;\n\t    this._dashOffset = -mathSqrt(dx * dx + dy * dy);\n\t  },\n\t  _dashedQuadraticTo: function (x1, y1, x2, y2) {\n\t    // Convert quadratic to cubic using degree elevation\n\t    var x3 = x2;\n\t    var y3 = y2;\n\t    x2 = (x2 + 2 * x1) / 3;\n\t    y2 = (y2 + 2 * y1) / 3;\n\t    x1 = (this._xi + 2 * x1) / 3;\n\t    y1 = (this._yi + 2 * y1) / 3;\n\t\n\t    this._dashedBezierTo(x1, y1, x2, y2, x3, y3);\n\t  },\n\t\n\t  /**\n\t   * 转成静态的 Float32Array 减少堆内存占用\n\t   * Convert dynamic array to static Float32Array\n\t   */\n\t  toStatic: function () {\n\t    var data = this.data;\n\t\n\t    if (data instanceof Array) {\n\t      data.length = this._len;\n\t\n\t      if (hasTypedArray) {\n\t        this.data = new Float32Array(data);\n\t      }\n\t    }\n\t  },\n\t\n\t  /**\n\t   * @return {module:zrender/core/BoundingRect}\n\t   */\n\t  getBoundingRect: function () {\n\t    min[0] = min[1] = min2[0] = min2[1] = Number.MAX_VALUE;\n\t    max[0] = max[1] = max2[0] = max2[1] = -Number.MAX_VALUE;\n\t    var data = this.data;\n\t    var xi = 0;\n\t    var yi = 0;\n\t    var x0 = 0;\n\t    var y0 = 0;\n\t\n\t    for (var i = 0; i < data.length;) {\n\t      var cmd = data[i++];\n\t\n\t      if (i == 1) {\n\t        // 如果第一个命令是 L, C, Q\n\t        // 则 previous point 同绘制命令的第一个 point\n\t        //\n\t        // 第一个命令为 Arc 的情况下会在后面特殊处理\n\t        xi = data[i];\n\t        yi = data[i + 1];\n\t        x0 = xi;\n\t        y0 = yi;\n\t      }\n\t\n\t      switch (cmd) {\n\t        case CMD.M:\n\t          // moveTo 命令重新创建一个新的 subpath, 并且更新新的起点\n\t          // 在 closePath 的时候使用\n\t          x0 = data[i++];\n\t          y0 = data[i++];\n\t          xi = x0;\n\t          yi = y0;\n\t          min2[0] = x0;\n\t          min2[1] = y0;\n\t          max2[0] = x0;\n\t          max2[1] = y0;\n\t          break;\n\t\n\t        case CMD.L:\n\t          bbox.fromLine(xi, yi, data[i], data[i + 1], min2, max2);\n\t          xi = data[i++];\n\t          yi = data[i++];\n\t          break;\n\t\n\t        case CMD.C:\n\t          bbox.fromCubic(xi, yi, data[i++], data[i++], data[i++], data[i++], data[i], data[i + 1], min2, max2);\n\t          xi = data[i++];\n\t          yi = data[i++];\n\t          break;\n\t\n\t        case CMD.Q:\n\t          bbox.fromQuadratic(xi, yi, data[i++], data[i++], data[i], data[i + 1], min2, max2);\n\t          xi = data[i++];\n\t          yi = data[i++];\n\t          break;\n\t\n\t        case CMD.A:\n\t          // TODO Arc 判断的开销比较大\n\t          var cx = data[i++];\n\t          var cy = data[i++];\n\t          var rx = data[i++];\n\t          var ry = data[i++];\n\t          var startAngle = data[i++];\n\t          var endAngle = data[i++] + startAngle; // TODO Arc 旋转\n\t\n\t          var psi = data[i++];\n\t          var anticlockwise = 1 - data[i++];\n\t\n\t          if (i == 1) {\n\t            // 直接使用 arc 命令\n\t            // 第一个命令起点还未定义\n\t            x0 = mathCos(startAngle) * rx + cx;\n\t            y0 = mathSin(startAngle) * ry + cy;\n\t          }\n\t\n\t          bbox.fromArc(cx, cy, rx, ry, startAngle, endAngle, anticlockwise, min2, max2);\n\t          xi = mathCos(endAngle) * rx + cx;\n\t          yi = mathSin(endAngle) * ry + cy;\n\t          break;\n\t\n\t        case CMD.R:\n\t          x0 = xi = data[i++];\n\t          y0 = yi = data[i++];\n\t          var width = data[i++];\n\t          var height = data[i++]; // Use fromLine\n\t\n\t          bbox.fromLine(x0, y0, x0 + width, y0 + height, min2, max2);\n\t          break;\n\t\n\t        case CMD.Z:\n\t          xi = x0;\n\t          yi = y0;\n\t          break;\n\t      } // Union\n\t\n\t\n\t      vec2.min(min, min, min2);\n\t      vec2.max(max, max, max2);\n\t    } // No data\n\t\n\t\n\t    if (i === 0) {\n\t      min[0] = min[1] = max[0] = max[1] = 0;\n\t    }\n\t\n\t    return new BoundingRect(min[0], min[1], max[0] - min[0], max[1] - min[1]);\n\t  },\n\t\n\t  /**\n\t   * Rebuild path from current data\n\t   * Rebuild path will not consider javascript implemented line dash.\n\t   * @param {CanvasRenderingContext2D} ctx\n\t   */\n\t  rebuildPath: function (ctx) {\n\t    var d = this.data;\n\t    var x0, y0;\n\t    var xi, yi;\n\t    var x, y;\n\t    var ux = this._ux;\n\t    var uy = this._uy;\n\t    var len = this._len;\n\t\n\t    for (var i = 0; i < len;) {\n\t      var cmd = d[i++];\n\t\n\t      if (i == 1) {\n\t        // 如果第一个命令是 L, C, Q\n\t        // 则 previous point 同绘制命令的第一个 point\n\t        //\n\t        // 第一个命令为 Arc 的情况下会在后面特殊处理\n\t        xi = d[i];\n\t        yi = d[i + 1];\n\t        x0 = xi;\n\t        y0 = yi;\n\t      }\n\t\n\t      switch (cmd) {\n\t        case CMD.M:\n\t          x0 = xi = d[i++];\n\t          y0 = yi = d[i++];\n\t          ctx.moveTo(xi, yi);\n\t          break;\n\t\n\t        case CMD.L:\n\t          x = d[i++];\n\t          y = d[i++]; // Not draw too small seg between\n\t\n\t          if (mathAbs(x - xi) > ux || mathAbs(y - yi) > uy || i === len - 1) {\n\t            ctx.lineTo(x, y);\n\t            xi = x;\n\t            yi = y;\n\t          }\n\t\n\t          break;\n\t\n\t        case CMD.C:\n\t          ctx.bezierCurveTo(d[i++], d[i++], d[i++], d[i++], d[i++], d[i++]);\n\t          xi = d[i - 2];\n\t          yi = d[i - 1];\n\t          break;\n\t\n\t        case CMD.Q:\n\t          ctx.quadraticCurveTo(d[i++], d[i++], d[i++], d[i++]);\n\t          xi = d[i - 2];\n\t          yi = d[i - 1];\n\t          break;\n\t\n\t        case CMD.A:\n\t          var cx = d[i++];\n\t          var cy = d[i++];\n\t          var rx = d[i++];\n\t          var ry = d[i++];\n\t          var theta = d[i++];\n\t          var dTheta = d[i++];\n\t          var psi = d[i++];\n\t          var fs = d[i++];\n\t          var r = rx > ry ? rx : ry;\n\t          var scaleX = rx > ry ? 1 : rx / ry;\n\t          var scaleY = rx > ry ? ry / rx : 1;\n\t          var isEllipse = Math.abs(rx - ry) > 1e-3;\n\t          var endAngle = theta + dTheta;\n\t\n\t          if (isEllipse) {\n\t            ctx.translate(cx, cy);\n\t            ctx.rotate(psi);\n\t            ctx.scale(scaleX, scaleY);\n\t            ctx.arc(0, 0, r, theta, endAngle, 1 - fs);\n\t            ctx.scale(1 / scaleX, 1 / scaleY);\n\t            ctx.rotate(-psi);\n\t            ctx.translate(-cx, -cy);\n\t          } else {\n\t            ctx.arc(cx, cy, r, theta, endAngle, 1 - fs);\n\t          }\n\t\n\t          if (i == 1) {\n\t            // 直接使用 arc 命令\n\t            // 第一个命令起点还未定义\n\t            x0 = mathCos(theta) * rx + cx;\n\t            y0 = mathSin(theta) * ry + cy;\n\t          }\n\t\n\t          xi = mathCos(endAngle) * rx + cx;\n\t          yi = mathSin(endAngle) * ry + cy;\n\t          break;\n\t\n\t        case CMD.R:\n\t          x0 = xi = d[i];\n\t          y0 = yi = d[i + 1];\n\t          ctx.rect(d[i++], d[i++], d[i++], d[i++]);\n\t          break;\n\t\n\t        case CMD.Z:\n\t          ctx.closePath();\n\t          xi = x0;\n\t          yi = y0;\n\t      }\n\t    }\n\t  }\n\t};\n\tPathProxy.CMD = CMD;\n\tvar _default = PathProxy;\n\tmodule.exports = _default;\n\n/***/ },\n/* 8 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar zrUtil = __webpack_require__(1);\n\t\n\tvar Style = __webpack_require__(55);\n\t\n\tvar Element = __webpack_require__(15);\n\t\n\tvar RectText = __webpack_require__(60);\n\t\n\t/**\n\t * 可绘制的图形基类\n\t * Base class of all displayable graphic objects\n\t * @module zrender/graphic/Displayable\n\t */\n\t\n\t/**\n\t * @alias module:zrender/graphic/Displayable\n\t * @extends module:zrender/Element\n\t * @extends module:zrender/graphic/mixin/RectText\n\t */\n\tfunction Displayable(opts) {\n\t  opts = opts || {};\n\t  Element.call(this, opts); // Extend properties\n\t\n\t  for (var name in opts) {\n\t    if (opts.hasOwnProperty(name) && name !== 'style') {\n\t      this[name] = opts[name];\n\t    }\n\t  }\n\t  /**\n\t   * @type {module:zrender/graphic/Style}\n\t   */\n\t\n\t\n\t  this.style = new Style(opts.style, this);\n\t  this._rect = null; // Shapes for cascade clipping.\n\t\n\t  this.__clipPaths = []; // FIXME Stateful must be mixined after style is setted\n\t  // Stateful.call(this, opts);\n\t}\n\t\n\tDisplayable.prototype = {\n\t  constructor: Displayable,\n\t  type: 'displayable',\n\t\n\t  /**\n\t   * Displayable 是否为脏，Painter 中会根据该标记判断是否需要是否需要重新绘制\n\t   * Dirty flag. From which painter will determine if this displayable object needs brush\n\t   * @name module:zrender/graphic/Displayable#__dirty\n\t   * @type {boolean}\n\t   */\n\t  __dirty: true,\n\t\n\t  /**\n\t   * 图形是否可见，为true时不绘制图形，但是仍能触发鼠标事件\n\t   * If ignore drawing of the displayable object. Mouse event will still be triggered\n\t   * @name module:/zrender/graphic/Displayable#invisible\n\t   * @type {boolean}\n\t   * @default false\n\t   */\n\t  invisible: false,\n\t\n\t  /**\n\t   * @name module:/zrender/graphic/Displayable#z\n\t   * @type {number}\n\t   * @default 0\n\t   */\n\t  z: 0,\n\t\n\t  /**\n\t   * @name module:/zrender/graphic/Displayable#z\n\t   * @type {number}\n\t   * @default 0\n\t   */\n\t  z2: 0,\n\t\n\t  /**\n\t   * z层level，决定绘画在哪层canvas中\n\t   * @name module:/zrender/graphic/Displayable#zlevel\n\t   * @type {number}\n\t   * @default 0\n\t   */\n\t  zlevel: 0,\n\t\n\t  /**\n\t   * 是否可拖拽\n\t   * @name module:/zrender/graphic/Displayable#draggable\n\t   * @type {boolean}\n\t   * @default false\n\t   */\n\t  draggable: false,\n\t\n\t  /**\n\t   * 是否正在拖拽\n\t   * @name module:/zrender/graphic/Displayable#draggable\n\t   * @type {boolean}\n\t   * @default false\n\t   */\n\t  dragging: false,\n\t\n\t  /**\n\t   * 是否相应鼠标事件\n\t   * @name module:/zrender/graphic/Displayable#silent\n\t   * @type {boolean}\n\t   * @default false\n\t   */\n\t  silent: false,\n\t\n\t  /**\n\t   * If enable culling\n\t   * @type {boolean}\n\t   * @default false\n\t   */\n\t  culling: false,\n\t\n\t  /**\n\t   * Mouse cursor when hovered\n\t   * @name module:/zrender/graphic/Displayable#cursor\n\t   * @type {string}\n\t   */\n\t  cursor: 'pointer',\n\t\n\t  /**\n\t   * If hover area is bounding rect\n\t   * @name module:/zrender/graphic/Displayable#rectHover\n\t   * @type {string}\n\t   */\n\t  rectHover: false,\n\t\n\t  /**\n\t   * Render the element progressively when the value >= 0,\n\t   * usefull for large data.\n\t   * @type {boolean}\n\t   */\n\t  progressive: false,\n\t\n\t  /**\n\t   * @type {boolean}\n\t   */\n\t  incremental: false,\n\t  // inplace is used with incremental\n\t  inplace: false,\n\t  beforeBrush: function (ctx) {},\n\t  afterBrush: function (ctx) {},\n\t\n\t  /**\n\t   * 图形绘制方法\n\t   * @param {CanvasRenderingContext2D} ctx\n\t   */\n\t  // Interface\n\t  brush: function (ctx, prevEl) {},\n\t\n\t  /**\n\t   * 获取最小包围盒\n\t   * @return {module:zrender/core/BoundingRect}\n\t   */\n\t  // Interface\n\t  getBoundingRect: function () {},\n\t\n\t  /**\n\t   * 判断坐标 x, y 是否在图形上\n\t   * If displayable element contain coord x, y\n\t   * @param  {number} x\n\t   * @param  {number} y\n\t   * @return {boolean}\n\t   */\n\t  contain: function (x, y) {\n\t    return this.rectContain(x, y);\n\t  },\n\t\n\t  /**\n\t   * @param  {Function} cb\n\t   * @param  {}   context\n\t   */\n\t  traverse: function (cb, context) {\n\t    cb.call(context, this);\n\t  },\n\t\n\t  /**\n\t   * 判断坐标 x, y 是否在图形的包围盒上\n\t   * If bounding rect of element contain coord x, y\n\t   * @param  {number} x\n\t   * @param  {number} y\n\t   * @return {boolean}\n\t   */\n\t  rectContain: function (x, y) {\n\t    var coord = this.transformCoordToLocal(x, y);\n\t    var rect = this.getBoundingRect();\n\t    return rect.contain(coord[0], coord[1]);\n\t  },\n\t\n\t  /**\n\t   * 标记图形元素为脏，并且在下一帧重绘\n\t   * Mark displayable element dirty and refresh next frame\n\t   */\n\t  dirty: function () {\n\t    this.__dirty = true;\n\t    this._rect = null;\n\t    this.__zr && this.__zr.refresh();\n\t  },\n\t\n\t  /**\n\t   * 图形是否会触发事件\n\t   * If displayable object binded any event\n\t   * @return {boolean}\n\t   */\n\t  // TODO, 通过 bind 绑定的事件\n\t  // isSilent: function () {\n\t  //     return !(\n\t  //         this.hoverable || this.draggable\n\t  //         || this.onmousemove || this.onmouseover || this.onmouseout\n\t  //         || this.onmousedown || this.onmouseup || this.onclick\n\t  //         || this.ondragenter || this.ondragover || this.ondragleave\n\t  //         || this.ondrop\n\t  //     );\n\t  // },\n\t\n\t  /**\n\t   * Alias for animate('style')\n\t   * @param {boolean} loop\n\t   */\n\t  animateStyle: function (loop) {\n\t    return this.animate('style', loop);\n\t  },\n\t  attrKV: function (key, value) {\n\t    if (key !== 'style') {\n\t      Element.prototype.attrKV.call(this, key, value);\n\t    } else {\n\t      this.style.set(value);\n\t    }\n\t  },\n\t\n\t  /**\n\t   * @param {Object|string} key\n\t   * @param {*} value\n\t   */\n\t  setStyle: function (key, value) {\n\t    this.style.set(key, value);\n\t    this.dirty(false);\n\t    return this;\n\t  },\n\t\n\t  /**\n\t   * Use given style object\n\t   * @param  {Object} obj\n\t   */\n\t  useStyle: function (obj) {\n\t    this.style = new Style(obj, this);\n\t    this.dirty(false);\n\t    return this;\n\t  }\n\t};\n\tzrUtil.inherits(Displayable, Element);\n\tzrUtil.mixin(Displayable, RectText); // zrUtil.mixin(Displayable, Stateful);\n\t\n\tvar _default = Displayable;\n\tmodule.exports = _default;\n\n/***/ },\n/* 9 */\n/***/ function(module, exports) {\n\n\tmodule.exports = __WEBPACK_EXTERNAL_MODULE_9__;\n\n/***/ },\n/* 10 */\n/***/ function(module, exports) {\n\n\t/**\n\t * 3x2矩阵操作类\n\t * @exports zrender/tool/matrix\n\t */\n\tvar ArrayCtor = typeof Float32Array === 'undefined' ? Array : Float32Array;\n\t/**\n\t * Create a identity matrix.\n\t * @return {Float32Array|Array.<number>}\n\t */\n\t\n\tfunction create() {\n\t  var out = new ArrayCtor(6);\n\t  identity(out);\n\t  return out;\n\t}\n\t/**\n\t * 设置矩阵为单位矩阵\n\t * @param {Float32Array|Array.<number>} out\n\t */\n\t\n\t\n\tfunction identity(out) {\n\t  out[0] = 1;\n\t  out[1] = 0;\n\t  out[2] = 0;\n\t  out[3] = 1;\n\t  out[4] = 0;\n\t  out[5] = 0;\n\t  return out;\n\t}\n\t/**\n\t * 复制矩阵\n\t * @param {Float32Array|Array.<number>} out\n\t * @param {Float32Array|Array.<number>} m\n\t */\n\t\n\t\n\tfunction copy(out, m) {\n\t  out[0] = m[0];\n\t  out[1] = m[1];\n\t  out[2] = m[2];\n\t  out[3] = m[3];\n\t  out[4] = m[4];\n\t  out[5] = m[5];\n\t  return out;\n\t}\n\t/**\n\t * 矩阵相乘\n\t * @param {Float32Array|Array.<number>} out\n\t * @param {Float32Array|Array.<number>} m1\n\t * @param {Float32Array|Array.<number>} m2\n\t */\n\t\n\t\n\tfunction mul(out, m1, m2) {\n\t  // Consider matrix.mul(m, m2, m);\n\t  // where out is the same as m2.\n\t  // So use temp variable to escape error.\n\t  var out0 = m1[0] * m2[0] + m1[2] * m2[1];\n\t  var out1 = m1[1] * m2[0] + m1[3] * m2[1];\n\t  var out2 = m1[0] * m2[2] + m1[2] * m2[3];\n\t  var out3 = m1[1] * m2[2] + m1[3] * m2[3];\n\t  var out4 = m1[0] * m2[4] + m1[2] * m2[5] + m1[4];\n\t  var out5 = m1[1] * m2[4] + m1[3] * m2[5] + m1[5];\n\t  out[0] = out0;\n\t  out[1] = out1;\n\t  out[2] = out2;\n\t  out[3] = out3;\n\t  out[4] = out4;\n\t  out[5] = out5;\n\t  return out;\n\t}\n\t/**\n\t * 平移变换\n\t * @param {Float32Array|Array.<number>} out\n\t * @param {Float32Array|Array.<number>} a\n\t * @param {Float32Array|Array.<number>} v\n\t */\n\t\n\t\n\tfunction translate(out, a, v) {\n\t  out[0] = a[0];\n\t  out[1] = a[1];\n\t  out[2] = a[2];\n\t  out[3] = a[3];\n\t  out[4] = a[4] + v[0];\n\t  out[5] = a[5] + v[1];\n\t  return out;\n\t}\n\t/**\n\t * 旋转变换\n\t * @param {Float32Array|Array.<number>} out\n\t * @param {Float32Array|Array.<number>} a\n\t * @param {number} rad\n\t */\n\t\n\t\n\tfunction rotate(out, a, rad) {\n\t  var aa = a[0];\n\t  var ac = a[2];\n\t  var atx = a[4];\n\t  var ab = a[1];\n\t  var ad = a[3];\n\t  var aty = a[5];\n\t  var st = Math.sin(rad);\n\t  var ct = Math.cos(rad);\n\t  out[0] = aa * ct + ab * st;\n\t  out[1] = -aa * st + ab * ct;\n\t  out[2] = ac * ct + ad * st;\n\t  out[3] = -ac * st + ct * ad;\n\t  out[4] = ct * atx + st * aty;\n\t  out[5] = ct * aty - st * atx;\n\t  return out;\n\t}\n\t/**\n\t * 缩放变换\n\t * @param {Float32Array|Array.<number>} out\n\t * @param {Float32Array|Array.<number>} a\n\t * @param {Float32Array|Array.<number>} v\n\t */\n\t\n\t\n\tfunction scale(out, a, v) {\n\t  var vx = v[0];\n\t  var vy = v[1];\n\t  out[0] = a[0] * vx;\n\t  out[1] = a[1] * vy;\n\t  out[2] = a[2] * vx;\n\t  out[3] = a[3] * vy;\n\t  out[4] = a[4] * vx;\n\t  out[5] = a[5] * vy;\n\t  return out;\n\t}\n\t/**\n\t * 求逆矩阵\n\t * @param {Float32Array|Array.<number>} out\n\t * @param {Float32Array|Array.<number>} a\n\t */\n\t\n\t\n\tfunction invert(out, a) {\n\t  var aa = a[0];\n\t  var ac = a[2];\n\t  var atx = a[4];\n\t  var ab = a[1];\n\t  var ad = a[3];\n\t  var aty = a[5];\n\t  var det = aa * ad - ab * ac;\n\t\n\t  if (!det) {\n\t    return null;\n\t  }\n\t\n\t  det = 1.0 / det;\n\t  out[0] = ad * det;\n\t  out[1] = -ab * det;\n\t  out[2] = -ac * det;\n\t  out[3] = aa * det;\n\t  out[4] = (ac * aty - ad * atx) * det;\n\t  out[5] = (ab * atx - aa * aty) * det;\n\t  return out;\n\t}\n\t/**\n\t * Clone a new matrix.\n\t * @param {Float32Array|Array.<number>} a\n\t */\n\t\n\t\n\tfunction clone(a) {\n\t  var b = create();\n\t  copy(b, a);\n\t  return b;\n\t}\n\t\n\texports.create = create;\n\texports.identity = identity;\n\texports.copy = copy;\n\texports.mul = mul;\n\texports.translate = translate;\n\texports.rotate = rotate;\n\texports.scale = scale;\n\texports.invert = invert;\n\texports.clone = clone;\n\n/***/ },\n/* 11 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar LRU = __webpack_require__(19);\n\t\n\tvar globalImageCache = new LRU(50);\n\t/**\n\t * @param {string|HTMLImageElement|HTMLCanvasElement|Canvas} newImageOrSrc\n\t * @return {HTMLImageElement|HTMLCanvasElement|Canvas} image\n\t */\n\t\n\tfunction findExistImage(newImageOrSrc) {\n\t  if (typeof newImageOrSrc === 'string') {\n\t    var cachedImgObj = globalImageCache.get(newImageOrSrc);\n\t    return cachedImgObj && cachedImgObj.image;\n\t  } else {\n\t    return newImageOrSrc;\n\t  }\n\t}\n\t/**\n\t * Caution: User should cache loaded images, but not just count on LRU.\n\t * Consider if required images more than LRU size, will dead loop occur?\n\t *\n\t * @param {string|HTMLImageElement|HTMLCanvasElement|Canvas} newImageOrSrc\n\t * @param {HTMLImageElement|HTMLCanvasElement|Canvas} image Existent image.\n\t * @param {module:zrender/Element} [hostEl] For calling `dirty`.\n\t * @param {Function} [cb] params: (image, cbPayload)\n\t * @param {Object} [cbPayload] Payload on cb calling.\n\t * @return {HTMLImageElement|HTMLCanvasElement|Canvas} image\n\t */\n\t\n\t\n\tfunction createOrUpdateImage(newImageOrSrc, image, hostEl, cb, cbPayload) {\n\t  if (!newImageOrSrc) {\n\t    return image;\n\t  } else if (typeof newImageOrSrc === 'string') {\n\t    // Image should not be loaded repeatly.\n\t    if (image && image.__zrImageSrc === newImageOrSrc || !hostEl) {\n\t      return image;\n\t    } // Only when there is no existent image or existent image src\n\t    // is different, this method is responsible for load.\n\t\n\t\n\t    var cachedImgObj = globalImageCache.get(newImageOrSrc);\n\t    var pendingWrap = {\n\t      hostEl: hostEl,\n\t      cb: cb,\n\t      cbPayload: cbPayload\n\t    };\n\t\n\t    if (cachedImgObj) {\n\t      image = cachedImgObj.image;\n\t      !isImageReady(image) && cachedImgObj.pending.push(pendingWrap);\n\t    } else {\n\t      !image && (image = new Image());\n\t      image.onload = imageOnLoad;\n\t      globalImageCache.put(newImageOrSrc, image.__cachedImgObj = {\n\t        image: image,\n\t        pending: [pendingWrap]\n\t      });\n\t      image.src = image.__zrImageSrc = newImageOrSrc;\n\t    }\n\t\n\t    return image;\n\t  } // newImageOrSrc is an HTMLImageElement or HTMLCanvasElement or Canvas\n\t  else {\n\t      return newImageOrSrc;\n\t    }\n\t}\n\t\n\tfunction imageOnLoad() {\n\t  var cachedImgObj = this.__cachedImgObj;\n\t  this.onload = this.__cachedImgObj = null;\n\t\n\t  for (var i = 0; i < cachedImgObj.pending.length; i++) {\n\t    var pendingWrap = cachedImgObj.pending[i];\n\t    var cb = pendingWrap.cb;\n\t    cb && cb(this, pendingWrap.cbPayload);\n\t    pendingWrap.hostEl.dirty();\n\t  }\n\t\n\t  cachedImgObj.pending.length = 0;\n\t}\n\t\n\tfunction isImageReady(image) {\n\t  return image && image.width && image.height;\n\t}\n\t\n\texports.findExistImage = findExistImage;\n\texports.createOrUpdateImage = createOrUpdateImage;\n\texports.isImageReady = isImageReady;\n\n/***/ },\n/* 12 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar _util = __webpack_require__(1);\n\t\n\tvar createHashMap = _util.createHashMap;\n\tvar isTypedArray = _util.isTypedArray;\n\t\n\tvar _clazz = __webpack_require__(31);\n\t\n\tvar enableClassCheck = _clazz.enableClassCheck;\n\t\n\tvar _sourceType = __webpack_require__(13);\n\t\n\tvar SOURCE_FORMAT_ORIGINAL = _sourceType.SOURCE_FORMAT_ORIGINAL;\n\tvar SERIES_LAYOUT_BY_COLUMN = _sourceType.SERIES_LAYOUT_BY_COLUMN;\n\tvar SOURCE_FORMAT_UNKNOWN = _sourceType.SOURCE_FORMAT_UNKNOWN;\n\tvar SOURCE_FORMAT_TYPED_ARRAY = _sourceType.SOURCE_FORMAT_TYPED_ARRAY;\n\tvar SOURCE_FORMAT_KEYED_COLUMNS = _sourceType.SOURCE_FORMAT_KEYED_COLUMNS;\n\t\n\t/**\n\t * [sourceFormat]\n\t *\n\t * + \"original\":\n\t * This format is only used in series.data, where\n\t * itemStyle can be specified in data item.\n\t *\n\t * + \"arrayRows\":\n\t * [\n\t *     ['product', 'score', 'amount'],\n\t *     ['Matcha Latte', 89.3, 95.8],\n\t *     ['Milk Tea', 92.1, 89.4],\n\t *     ['Cheese Cocoa', 94.4, 91.2],\n\t *     ['Walnut Brownie', 85.4, 76.9]\n\t * ]\n\t *\n\t * + \"objectRows\":\n\t * [\n\t *     {product: 'Matcha Latte', score: 89.3, amount: 95.8},\n\t *     {product: 'Milk Tea', score: 92.1, amount: 89.4},\n\t *     {product: 'Cheese Cocoa', score: 94.4, amount: 91.2},\n\t *     {product: 'Walnut Brownie', score: 85.4, amount: 76.9}\n\t * ]\n\t *\n\t * + \"keyedColumns\":\n\t * {\n\t *     'product': ['Matcha Latte', 'Milk Tea', 'Cheese Cocoa', 'Walnut Brownie'],\n\t *     'count': [823, 235, 1042, 988],\n\t *     'score': [95.8, 81.4, 91.2, 76.9]\n\t * }\n\t *\n\t * + \"typedArray\"\n\t *\n\t * + \"unknown\"\n\t */\n\t\n\t/**\n\t * @constructor\n\t * @param {Object} fields\n\t * @param {string} fields.sourceFormat\n\t * @param {Array|Object} fields.fromDataset\n\t * @param {Array|Object} [fields.data]\n\t * @param {string} [seriesLayoutBy='column']\n\t * @param {Array.<Object|string>} [dimensionsDefine]\n\t * @param {Objet|HashMap} [encodeDefine]\n\t * @param {number} [startIndex=0]\n\t * @param {number} [dimensionsDetectCount]\n\t */\n\tfunction Source(fields) {\n\t  /**\n\t   * @type {boolean}\n\t   */\n\t  this.fromDataset = fields.fromDataset;\n\t  /**\n\t   * Not null/undefined.\n\t   * @type {Array|Object}\n\t   */\n\t\n\t  this.data = fields.data || (fields.sourceFormat === SOURCE_FORMAT_KEYED_COLUMNS ? {} : []);\n\t  /**\n\t   * See also \"detectSourceFormat\".\n\t   * Not null/undefined.\n\t   * @type {string}\n\t   */\n\t\n\t  this.sourceFormat = fields.sourceFormat || SOURCE_FORMAT_UNKNOWN;\n\t  /**\n\t   * 'row' or 'column'\n\t   * Not null/undefined.\n\t   * @type {string} seriesLayoutBy\n\t   */\n\t\n\t  this.seriesLayoutBy = fields.seriesLayoutBy || SERIES_LAYOUT_BY_COLUMN;\n\t  /**\n\t   * dimensions definition in option.\n\t   * can be null/undefined.\n\t   * @type {Array.<Object|string>}\n\t   */\n\t\n\t  this.dimensionsDefine = fields.dimensionsDefine;\n\t  /**\n\t   * encode definition in option.\n\t   * can be null/undefined.\n\t   * @type {Objet|HashMap}\n\t   */\n\t\n\t  this.encodeDefine = fields.encodeDefine && createHashMap(fields.encodeDefine);\n\t  /**\n\t   * Not null/undefined, uint.\n\t   * @type {number}\n\t   */\n\t\n\t  this.startIndex = fields.startIndex || 0;\n\t  /**\n\t   * Can be null/undefined (when unknown), uint.\n\t   * @type {number}\n\t   */\n\t\n\t  this.dimensionsDetectCount = fields.dimensionsDetectCount;\n\t}\n\t/**\n\t * Wrap original series data for some compatibility cases.\n\t */\n\t\n\t\n\tSource.seriesDataToSource = function (data) {\n\t  return new Source({\n\t    data: data,\n\t    sourceFormat: isTypedArray(data) ? SOURCE_FORMAT_TYPED_ARRAY : SOURCE_FORMAT_ORIGINAL,\n\t    fromDataset: false\n\t  });\n\t};\n\t\n\tenableClassCheck(Source);\n\tvar _default = Source;\n\tmodule.exports = _default;\n\n/***/ },\n/* 13 */\n/***/ function(module, exports) {\n\n\t// Avoid typo.\n\tvar SOURCE_FORMAT_ORIGINAL = 'original';\n\tvar SOURCE_FORMAT_ARRAY_ROWS = 'arrayRows';\n\tvar SOURCE_FORMAT_OBJECT_ROWS = 'objectRows';\n\tvar SOURCE_FORMAT_KEYED_COLUMNS = 'keyedColumns';\n\tvar SOURCE_FORMAT_UNKNOWN = 'unknown'; // ??? CHANGE A NAME\n\t\n\tvar SOURCE_FORMAT_TYPED_ARRAY = 'typedArray';\n\tvar SERIES_LAYOUT_BY_COLUMN = 'column';\n\tvar SERIES_LAYOUT_BY_ROW = 'row';\n\texports.SOURCE_FORMAT_ORIGINAL = SOURCE_FORMAT_ORIGINAL;\n\texports.SOURCE_FORMAT_ARRAY_ROWS = SOURCE_FORMAT_ARRAY_ROWS;\n\texports.SOURCE_FORMAT_OBJECT_ROWS = SOURCE_FORMAT_OBJECT_ROWS;\n\texports.SOURCE_FORMAT_KEYED_COLUMNS = SOURCE_FORMAT_KEYED_COLUMNS;\n\texports.SOURCE_FORMAT_UNKNOWN = SOURCE_FORMAT_UNKNOWN;\n\texports.SOURCE_FORMAT_TYPED_ARRAY = SOURCE_FORMAT_TYPED_ARRAY;\n\texports.SERIES_LAYOUT_BY_COLUMN = SERIES_LAYOUT_BY_COLUMN;\n\texports.SERIES_LAYOUT_BY_ROW = SERIES_LAYOUT_BY_ROW;\n\n/***/ },\n/* 14 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar zrUtil = __webpack_require__(1);\n\t\n\tvar each = zrUtil.each;\n\tvar isObject = zrUtil.isObject;\n\tvar isArray = zrUtil.isArray;\n\t/**\n\t * name may be displayed on screen, so use '-'.\n\t * But we should make sure it is not duplicated\n\t * with user specified name, so use '\\0';\n\t */\n\t\n\tvar DEFAULT_COMPONENT_NAME = '\\0-';\n\t/**\n\t * If value is not array, then translate it to array.\n\t * @param  {*} value\n\t * @return {Array} [value] or value\n\t */\n\t\n\tfunction normalizeToArray(value) {\n\t  return value instanceof Array ? value : value == null ? [] : [value];\n\t}\n\t/**\n\t * Sync default option between normal and emphasis like `position` and `show`\n\t * In case some one will write code like\n\t *     label: {\n\t *          show: false,\n\t *          position: 'outside',\n\t *          fontSize: 18\n\t *     },\n\t *     emphasis: {\n\t *          label: { show: true }\n\t *     }\n\t * @param {Object} opt\n\t * @param {string} key\n\t * @param {Array.<string>} subOpts\n\t */\n\t\n\t\n\tfunction defaultEmphasis(opt, key, subOpts) {\n\t  if (opt) {\n\t    opt[key] = opt[key] || {};\n\t    opt.emphasis = opt.emphasis || {};\n\t    opt.emphasis[key] = opt.emphasis[key] || {}; // Default emphasis option from normal\n\t\n\t    for (var i = 0, len = subOpts.length; i < len; i++) {\n\t      var subOptName = subOpts[i];\n\t\n\t      if (!opt.emphasis[key].hasOwnProperty(subOptName) && opt[key].hasOwnProperty(subOptName)) {\n\t        opt.emphasis[key][subOptName] = opt[key][subOptName];\n\t      }\n\t    }\n\t  }\n\t}\n\t\n\tvar 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\t//     'position', 'offset', 'rotate', 'origin', 'show', 'distance', 'formatter',\n\t//     'fontStyle', 'fontWeight', 'fontSize', 'fontFamily',\n\t//     // FIXME: deprecated, check and remove it.\n\t//     'textStyle'\n\t// ]);\n\t\n\t/**\n\t * The method do not ensure performance.\n\t * data could be [12, 2323, {value: 223}, [1221, 23], {value: [2, 23]}]\n\t * This helper method retieves value from data.\n\t * @param {string|number|Date|Array|Object} dataItem\n\t * @return {number|string|Date|Array.<number|string|Date>}\n\t */\n\t\n\tfunction getDataItemValue(dataItem) {\n\t  return isObject(dataItem) && !isArray(dataItem) && !(dataItem instanceof Date) ? dataItem.value : dataItem;\n\t}\n\t/**\n\t * data could be [12, 2323, {value: 223}, [1221, 23], {value: [2, 23]}]\n\t * This helper method determine if dataItem has extra option besides value\n\t * @param {string|number|Date|Array|Object} dataItem\n\t */\n\t\n\t\n\tfunction isDataItemOption(dataItem) {\n\t  return isObject(dataItem) && !(dataItem instanceof Array); // // markLine data can be array\n\t  // && !(dataItem[0] && isObject(dataItem[0]) && !(dataItem[0] instanceof Array));\n\t}\n\t/**\n\t * Mapping to exists for merge.\n\t *\n\t * @public\n\t * @param {Array.<Object>|Array.<module:echarts/model/Component>} exists\n\t * @param {Object|Array.<Object>} newCptOptions\n\t * @return {Array.<Object>} Result, like [{exist: ..., option: ...}, {}],\n\t *                          index of which is the same as exists.\n\t */\n\t\n\t\n\tfunction mappingToExists(exists, newCptOptions) {\n\t  // Mapping by the order by original option (but not order of\n\t  // new option) in merge mode. Because we should ensure\n\t  // some specified index (like xAxisIndex) is consistent with\n\t  // original option, which is easy to understand, espatially in\n\t  // media query. And in most case, merge option is used to\n\t  // update partial option but not be expected to change order.\n\t  newCptOptions = (newCptOptions || []).slice();\n\t  var result = zrUtil.map(exists || [], function (obj, index) {\n\t    return {\n\t      exist: obj\n\t    };\n\t  }); // Mapping by id or name if specified.\n\t\n\t  each(newCptOptions, function (cptOption, index) {\n\t    if (!isObject(cptOption)) {\n\t      return;\n\t    } // id has highest priority.\n\t\n\t\n\t    for (var i = 0; i < result.length; i++) {\n\t      if (!result[i].option // Consider name: two map to one.\n\t      && cptOption.id != null && result[i].exist.id === cptOption.id + '') {\n\t        result[i].option = cptOption;\n\t        newCptOptions[index] = null;\n\t        return;\n\t      }\n\t    }\n\t\n\t    for (var i = 0; i < result.length; i++) {\n\t      var exist = result[i].exist;\n\t\n\t      if (!result[i].option // Consider name: two map to one.\n\t      // Can not match when both ids exist but different.\n\t      && (exist.id == null || cptOption.id == null) && cptOption.name != null && !isIdInner(cptOption) && !isIdInner(exist) && exist.name === cptOption.name + '') {\n\t        result[i].option = cptOption;\n\t        newCptOptions[index] = null;\n\t        return;\n\t      }\n\t    }\n\t  }); // Otherwise mapping by index.\n\t\n\t  each(newCptOptions, function (cptOption, index) {\n\t    if (!isObject(cptOption)) {\n\t      return;\n\t    }\n\t\n\t    var i = 0;\n\t\n\t    for (; i < result.length; i++) {\n\t      var exist = result[i].exist;\n\t\n\t      if (!result[i].option // Existing model that already has id should be able to\n\t      // mapped to (because after mapping performed model may\n\t      // be assigned with a id, whish should not affect next\n\t      // mapping), except those has inner id.\n\t      && !isIdInner(exist) // Caution:\n\t      // Do not overwrite id. But name can be overwritten,\n\t      // because axis use name as 'show label text'.\n\t      // 'exist' always has id and name and we dont\n\t      // need to check it.\n\t      && cptOption.id == null) {\n\t        result[i].option = cptOption;\n\t        break;\n\t      }\n\t    }\n\t\n\t    if (i >= result.length) {\n\t      result.push({\n\t        option: cptOption\n\t      });\n\t    }\n\t  });\n\t  return result;\n\t}\n\t/**\n\t * Make id and name for mapping result (result of mappingToExists)\n\t * into `keyInfo` field.\n\t *\n\t * @public\n\t * @param {Array.<Object>} Result, like [{exist: ..., option: ...}, {}],\n\t *                          which order is the same as exists.\n\t * @return {Array.<Object>} The input.\n\t */\n\t\n\t\n\tfunction makeIdAndName(mapResult) {\n\t  // We use this id to hash component models and view instances\n\t  // in echarts. id can be specified by user, or auto generated.\n\t  // The id generation rule ensures new view instance are able\n\t  // to mapped to old instance when setOption are called in\n\t  // no-merge mode. So we generate model id by name and plus\n\t  // type in view id.\n\t  // name can be duplicated among components, which is convenient\n\t  // to specify multi components (like series) by one name.\n\t  // Ensure that each id is distinct.\n\t  var idMap = zrUtil.createHashMap();\n\t  each(mapResult, function (item, index) {\n\t    var existCpt = item.exist;\n\t    existCpt && idMap.set(existCpt.id, item);\n\t  });\n\t  each(mapResult, function (item, index) {\n\t    var opt = item.option;\n\t    zrUtil.assert(!opt || opt.id == null || !idMap.get(opt.id) || idMap.get(opt.id) === item, 'id duplicates: ' + (opt && opt.id));\n\t    opt && opt.id != null && idMap.set(opt.id, item);\n\t    !item.keyInfo && (item.keyInfo = {});\n\t  }); // Make name and id.\n\t\n\t  each(mapResult, function (item, index) {\n\t    var existCpt = item.exist;\n\t    var opt = item.option;\n\t    var keyInfo = item.keyInfo;\n\t\n\t    if (!isObject(opt)) {\n\t      return;\n\t    } // name can be overwitten. Consider case: axis.name = '20km'.\n\t    // But id generated by name will not be changed, which affect\n\t    // only in that case: setOption with 'not merge mode' and view\n\t    // instance will be recreated, which can be accepted.\n\t\n\t\n\t    keyInfo.name = opt.name != null ? opt.name + '' : existCpt ? existCpt.name : DEFAULT_COMPONENT_NAME;\n\t\n\t    if (existCpt) {\n\t      keyInfo.id = existCpt.id;\n\t    } else if (opt.id != null) {\n\t      keyInfo.id = opt.id + '';\n\t    } else {\n\t      // Consider this situatoin:\n\t      //  optionA: [{name: 'a'}, {name: 'a'}, {..}]\n\t      //  optionB [{..}, {name: 'a'}, {name: 'a'}]\n\t      // Series with the same name between optionA and optionB\n\t      // should be mapped.\n\t      var idNum = 0;\n\t\n\t      do {\n\t        keyInfo.id = '\\0' + keyInfo.name + '\\0' + idNum++;\n\t      } while (idMap.get(keyInfo.id));\n\t    }\n\t\n\t    idMap.set(keyInfo.id, item);\n\t  });\n\t}\n\t/**\n\t * @public\n\t * @param {Object} cptOption\n\t * @return {boolean}\n\t */\n\t\n\t\n\tfunction isIdInner(cptOption) {\n\t  return isObject(cptOption) && cptOption.id && (cptOption.id + '').indexOf('\\0_ec_\\0') === 0;\n\t}\n\t/**\n\t * A helper for removing duplicate items between batchA and batchB,\n\t * and in themselves, and categorize by series.\n\t *\n\t * @param {Array.<Object>} batchA Like: [{seriesId: 2, dataIndex: [32, 4, 5]}, ...]\n\t * @param {Array.<Object>} batchB Like: [{seriesId: 2, dataIndex: [32, 4, 5]}, ...]\n\t * @return {Array.<Array.<Object>, Array.<Object>>} result: [resultBatchA, resultBatchB]\n\t */\n\t\n\t\n\tfunction compressBatches(batchA, batchB) {\n\t  var mapA = {};\n\t  var mapB = {};\n\t  makeMap(batchA || [], mapA);\n\t  makeMap(batchB || [], mapB, mapA);\n\t  return [mapToArray(mapA), mapToArray(mapB)];\n\t\n\t  function makeMap(sourceBatch, map, otherMap) {\n\t    for (var i = 0, len = sourceBatch.length; i < len; i++) {\n\t      var seriesId = sourceBatch[i].seriesId;\n\t      var dataIndices = normalizeToArray(sourceBatch[i].dataIndex);\n\t      var otherDataIndices = otherMap && otherMap[seriesId];\n\t\n\t      for (var j = 0, lenj = dataIndices.length; j < lenj; j++) {\n\t        var dataIndex = dataIndices[j];\n\t\n\t        if (otherDataIndices && otherDataIndices[dataIndex]) {\n\t          otherDataIndices[dataIndex] = null;\n\t        } else {\n\t          (map[seriesId] || (map[seriesId] = {}))[dataIndex] = 1;\n\t        }\n\t      }\n\t    }\n\t  }\n\t\n\t  function mapToArray(map, isData) {\n\t    var result = [];\n\t\n\t    for (var i in map) {\n\t      if (map.hasOwnProperty(i) && map[i] != null) {\n\t        if (isData) {\n\t          result.push(+i);\n\t        } else {\n\t          var dataIndices = mapToArray(map[i], true);\n\t          dataIndices.length && result.push({\n\t            seriesId: i,\n\t            dataIndex: dataIndices\n\t          });\n\t        }\n\t      }\n\t    }\n\t\n\t    return result;\n\t  }\n\t}\n\t/**\n\t * @param {module:echarts/data/List} data\n\t * @param {Object} payload Contains dataIndex (means rawIndex) / dataIndexInside / name\n\t *                         each of which can be Array or primary type.\n\t * @return {number|Array.<number>} dataIndex If not found, return undefined/null.\n\t */\n\t\n\t\n\tfunction queryDataIndex(data, payload) {\n\t  if (payload.dataIndexInside != null) {\n\t    return payload.dataIndexInside;\n\t  } else if (payload.dataIndex != null) {\n\t    return zrUtil.isArray(payload.dataIndex) ? zrUtil.map(payload.dataIndex, function (value) {\n\t      return data.indexOfRawIndex(value);\n\t    }) : data.indexOfRawIndex(payload.dataIndex);\n\t  } else if (payload.name != null) {\n\t    return zrUtil.isArray(payload.name) ? zrUtil.map(payload.name, function (value) {\n\t      return data.indexOfName(value);\n\t    }) : data.indexOfName(payload.name);\n\t  }\n\t}\n\t/**\n\t * Enable property storage to any host object.\n\t * Notice: Serialization is not supported.\n\t *\n\t * For example:\n\t * var inner = zrUitl.makeInner();\n\t *\n\t * function some1(hostObj) {\n\t *      inner(hostObj).someProperty = 1212;\n\t *      ...\n\t * }\n\t * function some2() {\n\t *      var fields = inner(this);\n\t *      fields.someProperty1 = 1212;\n\t *      fields.someProperty2 = 'xx';\n\t *      ...\n\t * }\n\t *\n\t * @return {Function}\n\t */\n\t\n\t\n\tfunction makeInner() {\n\t  // Consider different scope by es module import.\n\t  var key = '__\\0ec_inner_' + innerUniqueIndex++ + '_' + Math.random().toFixed(5);\n\t  return function (hostObj) {\n\t    return hostObj[key] || (hostObj[key] = {});\n\t  };\n\t}\n\t\n\tvar innerUniqueIndex = 0;\n\t/**\n\t * @param {module:echarts/model/Global} ecModel\n\t * @param {string|Object} finder\n\t *        If string, e.g., 'geo', means {geoIndex: 0}.\n\t *        If Object, could contain some of these properties below:\n\t *        {\n\t *            seriesIndex, seriesId, seriesName,\n\t *            geoIndex, geoId, geoName,\n\t *            bmapIndex, bmapId, bmapName,\n\t *            xAxisIndex, xAxisId, xAxisName,\n\t *            yAxisIndex, yAxisId, yAxisName,\n\t *            gridIndex, gridId, gridName,\n\t *            ... (can be extended)\n\t *        }\n\t *        Each properties can be number|string|Array.<number>|Array.<string>\n\t *        For example, a finder could be\n\t *        {\n\t *            seriesIndex: 3,\n\t *            geoId: ['aa', 'cc'],\n\t *            gridName: ['xx', 'rr']\n\t *        }\n\t *        xxxIndex can be set as 'all' (means all xxx) or 'none' (means not specify)\n\t *        If nothing or null/undefined specified, return nothing.\n\t * @param {Object} [opt]\n\t * @param {string} [opt.defaultMainType]\n\t * @param {Array.<string>} [opt.includeMainTypes]\n\t * @return {Object} result like:\n\t *        {\n\t *            seriesModels: [seriesModel1, seriesModel2],\n\t *            seriesModel: seriesModel1, // The first model\n\t *            geoModels: [geoModel1, geoModel2],\n\t *            geoModel: geoModel1, // The first model\n\t *            ...\n\t *        }\n\t */\n\t\n\tfunction parseFinder(ecModel, finder, opt) {\n\t  if (zrUtil.isString(finder)) {\n\t    var obj = {};\n\t    obj[finder + 'Index'] = 0;\n\t    finder = obj;\n\t  }\n\t\n\t  var defaultMainType = opt && opt.defaultMainType;\n\t\n\t  if (defaultMainType && !has(finder, defaultMainType + 'Index') && !has(finder, defaultMainType + 'Id') && !has(finder, defaultMainType + 'Name')) {\n\t    finder[defaultMainType + 'Index'] = 0;\n\t  }\n\t\n\t  var result = {};\n\t  each(finder, function (value, key) {\n\t    var value = finder[key]; // Exclude 'dataIndex' and other illgal keys.\n\t\n\t    if (key === 'dataIndex' || key === 'dataIndexInside') {\n\t      result[key] = value;\n\t      return;\n\t    }\n\t\n\t    var parsedKey = key.match(/^(\\w+)(Index|Id|Name)$/) || [];\n\t    var mainType = parsedKey[1];\n\t    var queryType = (parsedKey[2] || '').toLowerCase();\n\t\n\t    if (!mainType || !queryType || value == null || queryType === 'index' && value === 'none' || opt && opt.includeMainTypes && zrUtil.indexOf(opt.includeMainTypes, mainType) < 0) {\n\t      return;\n\t    }\n\t\n\t    var queryParam = {\n\t      mainType: mainType\n\t    };\n\t\n\t    if (queryType !== 'index' || value !== 'all') {\n\t      queryParam[queryType] = value;\n\t    }\n\t\n\t    var models = ecModel.queryComponents(queryParam);\n\t    result[mainType + 'Models'] = models;\n\t    result[mainType + 'Model'] = models[0];\n\t  });\n\t  return result;\n\t}\n\t\n\tfunction has(obj, prop) {\n\t  return obj && obj.hasOwnProperty(prop);\n\t}\n\t\n\tfunction setAttribute(dom, key, value) {\n\t  dom.setAttribute ? dom.setAttribute(key, value) : dom[key] = value;\n\t}\n\t\n\tfunction getAttribute(dom, key) {\n\t  return dom.getAttribute ? dom.getAttribute(key) : dom[key];\n\t}\n\t\n\texports.DEFAULT_COMPONENT_NAME = DEFAULT_COMPONENT_NAME;\n\texports.normalizeToArray = normalizeToArray;\n\texports.defaultEmphasis = defaultEmphasis;\n\texports.TEXT_STYLE_OPTIONS = TEXT_STYLE_OPTIONS;\n\texports.getDataItemValue = getDataItemValue;\n\texports.isDataItemOption = isDataItemOption;\n\texports.mappingToExists = mappingToExists;\n\texports.makeIdAndName = makeIdAndName;\n\texports.isIdInner = isIdInner;\n\texports.compressBatches = compressBatches;\n\texports.queryDataIndex = queryDataIndex;\n\texports.makeInner = makeInner;\n\texports.parseFinder = parseFinder;\n\texports.setAttribute = setAttribute;\n\texports.getAttribute = getAttribute;\n\n/***/ },\n/* 15 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar guid = __webpack_require__(47);\n\t\n\tvar Eventful = __webpack_require__(71);\n\t\n\tvar Transformable = __webpack_require__(25);\n\t\n\tvar Animatable = __webpack_require__(70);\n\t\n\tvar zrUtil = __webpack_require__(1);\n\t\n\t/**\n\t * @alias module:zrender/Element\n\t * @constructor\n\t * @extends {module:zrender/mixin/Animatable}\n\t * @extends {module:zrender/mixin/Transformable}\n\t * @extends {module:zrender/mixin/Eventful}\n\t */\n\tvar Element = function (opts) {\n\t  // jshint ignore:line\n\t  Transformable.call(this, opts);\n\t  Eventful.call(this, opts);\n\t  Animatable.call(this, opts);\n\t  /**\n\t   * 画布元素ID\n\t   * @type {string}\n\t   */\n\t\n\t  this.id = opts.id || guid();\n\t};\n\t\n\tElement.prototype = {\n\t  /**\n\t   * 元素类型\n\t   * Element type\n\t   * @type {string}\n\t   */\n\t  type: 'element',\n\t\n\t  /**\n\t   * 元素名字\n\t   * Element name\n\t   * @type {string}\n\t   */\n\t  name: '',\n\t\n\t  /**\n\t   * ZRender 实例对象，会在 element 添加到 zrender 实例中后自动赋值\n\t   * ZRender instance will be assigned when element is associated with zrender\n\t   * @name module:/zrender/Element#__zr\n\t   * @type {module:zrender/ZRender}\n\t   */\n\t  __zr: null,\n\t\n\t  /**\n\t   * 图形是否忽略，为true时忽略图形的绘制以及事件触发\n\t   * If ignore drawing and events of the element object\n\t   * @name module:/zrender/Element#ignore\n\t   * @type {boolean}\n\t   * @default false\n\t   */\n\t  ignore: false,\n\t\n\t  /**\n\t   * 用于裁剪的路径(shape)，所有 Group 内的路径在绘制时都会被这个路径裁剪\n\t   * 该路径会继承被裁减对象的变换\n\t   * @type {module:zrender/graphic/Path}\n\t   * @see http://www.w3.org/TR/2dcontext/#clipping-region\n\t   * @readOnly\n\t   */\n\t  clipPath: null,\n\t\n\t  /**\n\t   * 是否是 Group\n\t   * @type {boolean}\n\t   */\n\t  isGroup: false,\n\t\n\t  /**\n\t   * Drift element\n\t   * @param  {number} dx dx on the global space\n\t   * @param  {number} dy dy on the global space\n\t   */\n\t  drift: function (dx, dy) {\n\t    switch (this.draggable) {\n\t      case 'horizontal':\n\t        dy = 0;\n\t        break;\n\t\n\t      case 'vertical':\n\t        dx = 0;\n\t        break;\n\t    }\n\t\n\t    var m = this.transform;\n\t\n\t    if (!m) {\n\t      m = this.transform = [1, 0, 0, 1, 0, 0];\n\t    }\n\t\n\t    m[4] += dx;\n\t    m[5] += dy;\n\t    this.decomposeTransform();\n\t    this.dirty(false);\n\t  },\n\t\n\t  /**\n\t   * Hook before update\n\t   */\n\t  beforeUpdate: function () {},\n\t\n\t  /**\n\t   * Hook after update\n\t   */\n\t  afterUpdate: function () {},\n\t\n\t  /**\n\t   * Update each frame\n\t   */\n\t  update: function () {\n\t    this.updateTransform();\n\t  },\n\t\n\t  /**\n\t   * @param  {Function} cb\n\t   * @param  {}   context\n\t   */\n\t  traverse: function (cb, context) {},\n\t\n\t  /**\n\t   * @protected\n\t   */\n\t  attrKV: function (key, value) {\n\t    if (key === 'position' || key === 'scale' || key === 'origin') {\n\t      // Copy the array\n\t      if (value) {\n\t        var target = this[key];\n\t\n\t        if (!target) {\n\t          target = this[key] = [];\n\t        }\n\t\n\t        target[0] = value[0];\n\t        target[1] = value[1];\n\t      }\n\t    } else {\n\t      this[key] = value;\n\t    }\n\t  },\n\t\n\t  /**\n\t   * Hide the element\n\t   */\n\t  hide: function () {\n\t    this.ignore = true;\n\t    this.__zr && this.__zr.refresh();\n\t  },\n\t\n\t  /**\n\t   * Show the element\n\t   */\n\t  show: function () {\n\t    this.ignore = false;\n\t    this.__zr && this.__zr.refresh();\n\t  },\n\t\n\t  /**\n\t   * @param {string|Object} key\n\t   * @param {*} value\n\t   */\n\t  attr: function (key, value) {\n\t    if (typeof key === 'string') {\n\t      this.attrKV(key, value);\n\t    } else if (zrUtil.isObject(key)) {\n\t      for (var name in key) {\n\t        if (key.hasOwnProperty(name)) {\n\t          this.attrKV(name, key[name]);\n\t        }\n\t      }\n\t    }\n\t\n\t    this.dirty(false);\n\t    return this;\n\t  },\n\t\n\t  /**\n\t   * @param {module:zrender/graphic/Path} clipPath\n\t   */\n\t  setClipPath: function (clipPath) {\n\t    var zr = this.__zr;\n\t\n\t    if (zr) {\n\t      clipPath.addSelfToZr(zr);\n\t    } // Remove previous clip path\n\t\n\t\n\t    if (this.clipPath && this.clipPath !== clipPath) {\n\t      this.removeClipPath();\n\t    }\n\t\n\t    this.clipPath = clipPath;\n\t    clipPath.__zr = zr;\n\t    clipPath.__clipTarget = this;\n\t    this.dirty(false);\n\t  },\n\t\n\t  /**\n\t   */\n\t  removeClipPath: function () {\n\t    var clipPath = this.clipPath;\n\t\n\t    if (clipPath) {\n\t      if (clipPath.__zr) {\n\t        clipPath.removeSelfFromZr(clipPath.__zr);\n\t      }\n\t\n\t      clipPath.__zr = null;\n\t      clipPath.__clipTarget = null;\n\t      this.clipPath = null;\n\t      this.dirty(false);\n\t    }\n\t  },\n\t\n\t  /**\n\t   * Add self from zrender instance.\n\t   * Not recursively because it will be invoked when element added to storage.\n\t   * @param {module:zrender/ZRender} zr\n\t   */\n\t  addSelfToZr: function (zr) {\n\t    this.__zr = zr; // 添加动画\n\t\n\t    var animators = this.animators;\n\t\n\t    if (animators) {\n\t      for (var i = 0; i < animators.length; i++) {\n\t        zr.animation.addAnimator(animators[i]);\n\t      }\n\t    }\n\t\n\t    if (this.clipPath) {\n\t      this.clipPath.addSelfToZr(zr);\n\t    }\n\t  },\n\t\n\t  /**\n\t   * Remove self from zrender instance.\n\t   * Not recursively because it will be invoked when element added to storage.\n\t   * @param {module:zrender/ZRender} zr\n\t   */\n\t  removeSelfFromZr: function (zr) {\n\t    this.__zr = null; // 移除动画\n\t\n\t    var animators = this.animators;\n\t\n\t    if (animators) {\n\t      for (var i = 0; i < animators.length; i++) {\n\t        zr.animation.removeAnimator(animators[i]);\n\t      }\n\t    }\n\t\n\t    if (this.clipPath) {\n\t      this.clipPath.removeSelfFromZr(zr);\n\t    }\n\t  }\n\t};\n\tzrUtil.mixin(Element, Animatable);\n\tzrUtil.mixin(Element, Transformable);\n\tzrUtil.mixin(Element, Eventful);\n\tvar _default = Element;\n\tmodule.exports = _default;\n\n/***/ },\n/* 16 */\n/***/ function(module, exports) {\n\n\tvar dpr = 1; // If in browser environment\n\t\n\tif (typeof window !== 'undefined') {\n\t  dpr = Math.max(window.devicePixelRatio || 1, 1);\n\t}\n\t/**\n\t * config默认配置项\n\t * @exports zrender/config\n\t * @author Kener (@Kener-林峰, kener.linfeng@gmail.com)\n\t */\n\t\n\t/**\n\t * debug日志选项：catchBrushException为true下有效\n\t * 0 : 不生成debug数据，发布用\n\t * 1 : 异常抛出，调试用\n\t * 2 : 控制台输出，调试用\n\t */\n\t\n\t\n\tvar debugMode = 0; // retina 屏幕优化\n\t\n\tvar devicePixelRatio = dpr;\n\texports.debugMode = debugMode;\n\texports.devicePixelRatio = devicePixelRatio;\n\n/***/ },\n/* 17 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar BoundingRect = __webpack_require__(4);\n\t\n\tvar imageHelper = __webpack_require__(11);\n\t\n\tvar _util = __webpack_require__(1);\n\t\n\tvar getContext = _util.getContext;\n\tvar extend = _util.extend;\n\tvar retrieve2 = _util.retrieve2;\n\tvar retrieve3 = _util.retrieve3;\n\tvar trim = _util.trim;\n\tvar textWidthCache = {};\n\tvar textWidthCacheCounter = 0;\n\tvar TEXT_CACHE_MAX = 5000;\n\tvar STYLE_REG = /\\{([a-zA-Z0-9_]+)\\|([^}]*)\\}/g;\n\tvar DEFAULT_FONT = '12px sans-serif'; // Avoid assign to an exported variable, for transforming to cjs.\n\t\n\tvar methods = {};\n\t\n\tfunction $override(name, fn) {\n\t  methods[name] = fn;\n\t}\n\t/**\n\t * @public\n\t * @param {string} text\n\t * @param {string} font\n\t * @return {number} width\n\t */\n\t\n\t\n\tfunction getWidth(text, font) {\n\t  font = font || DEFAULT_FONT;\n\t  var key = text + ':' + font;\n\t\n\t  if (textWidthCache[key]) {\n\t    return textWidthCache[key];\n\t  }\n\t\n\t  var textLines = (text + '').split('\\n');\n\t  var width = 0;\n\t\n\t  for (var i = 0, l = textLines.length; i < l; i++) {\n\t    // textContain.measureText may be overrided in SVG or VML\n\t    width = Math.max(measureText(textLines[i], font).width, width);\n\t  }\n\t\n\t  if (textWidthCacheCounter > TEXT_CACHE_MAX) {\n\t    textWidthCacheCounter = 0;\n\t    textWidthCache = {};\n\t  }\n\t\n\t  textWidthCacheCounter++;\n\t  textWidthCache[key] = width;\n\t  return width;\n\t}\n\t/**\n\t * @public\n\t * @param {string} text\n\t * @param {string} font\n\t * @param {string} [textAlign='left']\n\t * @param {string} [textVerticalAlign='top']\n\t * @param {Array.<number>} [textPadding]\n\t * @param {Object} [rich]\n\t * @param {Object} [truncate]\n\t * @return {Object} {x, y, width, height, lineHeight}\n\t */\n\t\n\t\n\tfunction getBoundingRect(text, font, textAlign, textVerticalAlign, textPadding, rich, truncate) {\n\t  return rich ? getRichTextRect(text, font, textAlign, textVerticalAlign, textPadding, rich, truncate) : getPlainTextRect(text, font, textAlign, textVerticalAlign, textPadding, truncate);\n\t}\n\t\n\tfunction getPlainTextRect(text, font, textAlign, textVerticalAlign, textPadding, truncate) {\n\t  var contentBlock = parsePlainText(text, font, textPadding, truncate);\n\t  var outerWidth = getWidth(text, font);\n\t\n\t  if (textPadding) {\n\t    outerWidth += textPadding[1] + textPadding[3];\n\t  }\n\t\n\t  var outerHeight = contentBlock.outerHeight;\n\t  var x = adjustTextX(0, outerWidth, textAlign);\n\t  var y = adjustTextY(0, outerHeight, textVerticalAlign);\n\t  var rect = new BoundingRect(x, y, outerWidth, outerHeight);\n\t  rect.lineHeight = contentBlock.lineHeight;\n\t  return rect;\n\t}\n\t\n\tfunction getRichTextRect(text, font, textAlign, textVerticalAlign, textPadding, rich, truncate) {\n\t  var contentBlock = parseRichText(text, {\n\t    rich: rich,\n\t    truncate: truncate,\n\t    font: font,\n\t    textAlign: textAlign,\n\t    textPadding: textPadding\n\t  });\n\t  var outerWidth = contentBlock.outerWidth;\n\t  var outerHeight = contentBlock.outerHeight;\n\t  var x = adjustTextX(0, outerWidth, textAlign);\n\t  var y = adjustTextY(0, outerHeight, textVerticalAlign);\n\t  return new BoundingRect(x, y, outerWidth, outerHeight);\n\t}\n\t/**\n\t * @public\n\t * @param {number} x\n\t * @param {number} width\n\t * @param {string} [textAlign='left']\n\t * @return {number} Adjusted x.\n\t */\n\t\n\t\n\tfunction adjustTextX(x, width, textAlign) {\n\t  // FIXME Right to left language\n\t  if (textAlign === 'right') {\n\t    x -= width;\n\t  } else if (textAlign === 'center') {\n\t    x -= width / 2;\n\t  }\n\t\n\t  return x;\n\t}\n\t/**\n\t * @public\n\t * @param {number} y\n\t * @param {number} height\n\t * @param {string} [textVerticalAlign='top']\n\t * @return {number} Adjusted y.\n\t */\n\t\n\t\n\tfunction adjustTextY(y, height, textVerticalAlign) {\n\t  if (textVerticalAlign === 'middle') {\n\t    y -= height / 2;\n\t  } else if (textVerticalAlign === 'bottom') {\n\t    y -= height;\n\t  }\n\t\n\t  return y;\n\t}\n\t/**\n\t * @public\n\t * @param {stirng} textPosition\n\t * @param {Object} rect {x, y, width, height}\n\t * @param {number} distance\n\t * @return {Object} {x, y, textAlign, textVerticalAlign}\n\t */\n\t\n\t\n\tfunction adjustTextPositionOnRect(textPosition, rect, distance) {\n\t  var x = rect.x;\n\t  var y = rect.y;\n\t  var height = rect.height;\n\t  var width = rect.width;\n\t  var halfHeight = height / 2;\n\t  var textAlign = 'left';\n\t  var textVerticalAlign = 'top';\n\t\n\t  switch (textPosition) {\n\t    case 'left':\n\t      x -= distance;\n\t      y += halfHeight;\n\t      textAlign = 'right';\n\t      textVerticalAlign = 'middle';\n\t      break;\n\t\n\t    case 'right':\n\t      x += distance + width;\n\t      y += halfHeight;\n\t      textVerticalAlign = 'middle';\n\t      break;\n\t\n\t    case 'top':\n\t      x += width / 2;\n\t      y -= distance;\n\t      textAlign = 'center';\n\t      textVerticalAlign = 'bottom';\n\t      break;\n\t\n\t    case 'bottom':\n\t      x += width / 2;\n\t      y += height + distance;\n\t      textAlign = 'center';\n\t      break;\n\t\n\t    case 'inside':\n\t      x += width / 2;\n\t      y += halfHeight;\n\t      textAlign = 'center';\n\t      textVerticalAlign = 'middle';\n\t      break;\n\t\n\t    case 'insideLeft':\n\t      x += distance;\n\t      y += halfHeight;\n\t      textVerticalAlign = 'middle';\n\t      break;\n\t\n\t    case 'insideRight':\n\t      x += width - distance;\n\t      y += halfHeight;\n\t      textAlign = 'right';\n\t      textVerticalAlign = 'middle';\n\t      break;\n\t\n\t    case 'insideTop':\n\t      x += width / 2;\n\t      y += distance;\n\t      textAlign = 'center';\n\t      break;\n\t\n\t    case 'insideBottom':\n\t      x += width / 2;\n\t      y += height - distance;\n\t      textAlign = 'center';\n\t      textVerticalAlign = 'bottom';\n\t      break;\n\t\n\t    case 'insideTopLeft':\n\t      x += distance;\n\t      y += distance;\n\t      break;\n\t\n\t    case 'insideTopRight':\n\t      x += width - distance;\n\t      y += distance;\n\t      textAlign = 'right';\n\t      break;\n\t\n\t    case 'insideBottomLeft':\n\t      x += distance;\n\t      y += height - distance;\n\t      textVerticalAlign = 'bottom';\n\t      break;\n\t\n\t    case 'insideBottomRight':\n\t      x += width - distance;\n\t      y += height - distance;\n\t      textAlign = 'right';\n\t      textVerticalAlign = 'bottom';\n\t      break;\n\t  }\n\t\n\t  return {\n\t    x: x,\n\t    y: y,\n\t    textAlign: textAlign,\n\t    textVerticalAlign: textVerticalAlign\n\t  };\n\t}\n\t/**\n\t * Show ellipsis if overflow.\n\t *\n\t * @public\n\t * @param  {string} text\n\t * @param  {string} containerWidth\n\t * @param  {string} font\n\t * @param  {number} [ellipsis='...']\n\t * @param  {Object} [options]\n\t * @param  {number} [options.maxIterations=3]\n\t * @param  {number} [options.minChar=0] If truncate result are less\n\t *                  then minChar, ellipsis will not show, which is\n\t *                  better for user hint in some cases.\n\t * @param  {number} [options.placeholder=''] When all truncated, use the placeholder.\n\t * @return {string}\n\t */\n\t\n\t\n\tfunction truncateText(text, containerWidth, font, ellipsis, options) {\n\t  if (!containerWidth) {\n\t    return '';\n\t  }\n\t\n\t  var textLines = (text + '').split('\\n');\n\t  options = prepareTruncateOptions(containerWidth, font, ellipsis, options); // FIXME\n\t  // It is not appropriate that every line has '...' when truncate multiple lines.\n\t\n\t  for (var i = 0, len = textLines.length; i < len; i++) {\n\t    textLines[i] = truncateSingleLine(textLines[i], options);\n\t  }\n\t\n\t  return textLines.join('\\n');\n\t}\n\t\n\tfunction prepareTruncateOptions(containerWidth, font, ellipsis, options) {\n\t  options = extend({}, options);\n\t  options.font = font;\n\t  var ellipsis = retrieve2(ellipsis, '...');\n\t  options.maxIterations = retrieve2(options.maxIterations, 2);\n\t  var minChar = options.minChar = retrieve2(options.minChar, 0); // FIXME\n\t  // Other languages?\n\t\n\t  options.cnCharWidth = getWidth('国', font); // FIXME\n\t  // Consider proportional font?\n\t\n\t  var ascCharWidth = options.ascCharWidth = getWidth('a', font);\n\t  options.placeholder = retrieve2(options.placeholder, ''); // Example 1: minChar: 3, text: 'asdfzxcv', truncate result: 'asdf', but not: 'a...'.\n\t  // Example 2: minChar: 3, text: '维度', truncate result: '维', but not: '...'.\n\t\n\t  var contentWidth = containerWidth = Math.max(0, containerWidth - 1); // Reserve some gap.\n\t\n\t  for (var i = 0; i < minChar && contentWidth >= ascCharWidth; i++) {\n\t    contentWidth -= ascCharWidth;\n\t  }\n\t\n\t  var ellipsisWidth = getWidth(ellipsis);\n\t\n\t  if (ellipsisWidth > contentWidth) {\n\t    ellipsis = '';\n\t    ellipsisWidth = 0;\n\t  }\n\t\n\t  contentWidth = containerWidth - ellipsisWidth;\n\t  options.ellipsis = ellipsis;\n\t  options.ellipsisWidth = ellipsisWidth;\n\t  options.contentWidth = contentWidth;\n\t  options.containerWidth = containerWidth;\n\t  return options;\n\t}\n\t\n\tfunction truncateSingleLine(textLine, options) {\n\t  var containerWidth = options.containerWidth;\n\t  var font = options.font;\n\t  var contentWidth = options.contentWidth;\n\t\n\t  if (!containerWidth) {\n\t    return '';\n\t  }\n\t\n\t  var lineWidth = getWidth(textLine, font);\n\t\n\t  if (lineWidth <= containerWidth) {\n\t    return textLine;\n\t  }\n\t\n\t  for (var j = 0;; j++) {\n\t    if (lineWidth <= contentWidth || j >= options.maxIterations) {\n\t      textLine += options.ellipsis;\n\t      break;\n\t    }\n\t\n\t    var subLength = j === 0 ? estimateLength(textLine, contentWidth, options.ascCharWidth, options.cnCharWidth) : lineWidth > 0 ? Math.floor(textLine.length * contentWidth / lineWidth) : 0;\n\t    textLine = textLine.substr(0, subLength);\n\t    lineWidth = getWidth(textLine, font);\n\t  }\n\t\n\t  if (textLine === '') {\n\t    textLine = options.placeholder;\n\t  }\n\t\n\t  return textLine;\n\t}\n\t\n\tfunction estimateLength(text, contentWidth, ascCharWidth, cnCharWidth) {\n\t  var width = 0;\n\t  var i = 0;\n\t\n\t  for (var len = text.length; i < len && width < contentWidth; i++) {\n\t    var charCode = text.charCodeAt(i);\n\t    width += 0 <= charCode && charCode <= 127 ? ascCharWidth : cnCharWidth;\n\t  }\n\t\n\t  return i;\n\t}\n\t/**\n\t * @public\n\t * @param {string} font\n\t * @return {number} line height\n\t */\n\t\n\t\n\tfunction getLineHeight(font) {\n\t  // FIXME A rough approach.\n\t  return getWidth('国', font);\n\t}\n\t/**\n\t * @public\n\t * @param {string} text\n\t * @param {string} font\n\t * @return {Object} width\n\t */\n\t\n\t\n\tfunction measureText(text, font) {\n\t  return methods.measureText(text, font);\n\t} // Avoid assign to an exported variable, for transforming to cjs.\n\t\n\t\n\tmethods.measureText = function (text, font) {\n\t  var ctx = getContext();\n\t  ctx.font = font || DEFAULT_FONT;\n\t  return ctx.measureText(text);\n\t};\n\t/**\n\t * @public\n\t * @param {string} text\n\t * @param {string} font\n\t * @param {Object} [truncate]\n\t * @return {Object} block: {lineHeight, lines, height, outerHeight}\n\t *  Notice: for performance, do not calculate outerWidth util needed.\n\t */\n\t\n\t\n\tfunction parsePlainText(text, font, padding, truncate) {\n\t  text != null && (text += '');\n\t  var lineHeight = getLineHeight(font);\n\t  var lines = text ? text.split('\\n') : [];\n\t  var height = lines.length * lineHeight;\n\t  var outerHeight = height;\n\t\n\t  if (padding) {\n\t    outerHeight += padding[0] + padding[2];\n\t  }\n\t\n\t  if (text && truncate) {\n\t    var truncOuterHeight = truncate.outerHeight;\n\t    var truncOuterWidth = truncate.outerWidth;\n\t\n\t    if (truncOuterHeight != null && outerHeight > truncOuterHeight) {\n\t      text = '';\n\t      lines = [];\n\t    } else if (truncOuterWidth != null) {\n\t      var options = prepareTruncateOptions(truncOuterWidth - (padding ? padding[1] + padding[3] : 0), font, truncate.ellipsis, {\n\t        minChar: truncate.minChar,\n\t        placeholder: truncate.placeholder\n\t      }); // FIXME\n\t      // It is not appropriate that every line has '...' when truncate multiple lines.\n\t\n\t      for (var i = 0, len = lines.length; i < len; i++) {\n\t        lines[i] = truncateSingleLine(lines[i], options);\n\t      }\n\t    }\n\t  }\n\t\n\t  return {\n\t    lines: lines,\n\t    height: height,\n\t    outerHeight: outerHeight,\n\t    lineHeight: lineHeight\n\t  };\n\t}\n\t/**\n\t * For example: 'some text {a|some text}other text{b|some text}xxx{c|}xxx'\n\t * Also consider 'bbbb{a|xxx\\nzzz}xxxx\\naaaa'.\n\t *\n\t * @public\n\t * @param {string} text\n\t * @param {Object} style\n\t * @return {Object} block\n\t * {\n\t *      width,\n\t *      height,\n\t *      lines: [{\n\t *          lineHeight,\n\t *          width,\n\t *          tokens: [[{\n\t *              styleName,\n\t *              text,\n\t *              width,      // include textPadding\n\t *              height,     // include textPadding\n\t *              textWidth, // pure text width\n\t *              textHeight, // pure text height\n\t *              lineHeihgt,\n\t *              font,\n\t *              textAlign,\n\t *              textVerticalAlign\n\t *          }], [...], ...]\n\t *      }, ...]\n\t * }\n\t * If styleName is undefined, it is plain text.\n\t */\n\t\n\t\n\tfunction parseRichText(text, style) {\n\t  var contentBlock = {\n\t    lines: [],\n\t    width: 0,\n\t    height: 0\n\t  };\n\t  text != null && (text += '');\n\t\n\t  if (!text) {\n\t    return contentBlock;\n\t  }\n\t\n\t  var lastIndex = STYLE_REG.lastIndex = 0;\n\t  var result;\n\t\n\t  while ((result = STYLE_REG.exec(text)) != null) {\n\t    var matchedIndex = result.index;\n\t\n\t    if (matchedIndex > lastIndex) {\n\t      pushTokens(contentBlock, text.substring(lastIndex, matchedIndex));\n\t    }\n\t\n\t    pushTokens(contentBlock, result[2], result[1]);\n\t    lastIndex = STYLE_REG.lastIndex;\n\t  }\n\t\n\t  if (lastIndex < text.length) {\n\t    pushTokens(contentBlock, text.substring(lastIndex, text.length));\n\t  }\n\t\n\t  var lines = contentBlock.lines;\n\t  var contentHeight = 0;\n\t  var contentWidth = 0; // For `textWidth: 100%`\n\t\n\t  var pendingList = [];\n\t  var stlPadding = style.textPadding;\n\t  var truncate = style.truncate;\n\t  var truncateWidth = truncate && truncate.outerWidth;\n\t  var truncateHeight = truncate && truncate.outerHeight;\n\t\n\t  if (stlPadding) {\n\t    truncateWidth != null && (truncateWidth -= stlPadding[1] + stlPadding[3]);\n\t    truncateHeight != null && (truncateHeight -= stlPadding[0] + stlPadding[2]);\n\t  } // Calculate layout info of tokens.\n\t\n\t\n\t  for (var i = 0; i < lines.length; i++) {\n\t    var line = lines[i];\n\t    var lineHeight = 0;\n\t    var lineWidth = 0;\n\t\n\t    for (var j = 0; j < line.tokens.length; j++) {\n\t      var token = line.tokens[j];\n\t      var tokenStyle = token.styleName && style.rich[token.styleName] || {}; // textPadding should not inherit from style.\n\t\n\t      var textPadding = token.textPadding = tokenStyle.textPadding; // textFont has been asigned to font by `normalizeStyle`.\n\t\n\t      var font = token.font = tokenStyle.font || style.font; // textHeight can be used when textVerticalAlign is specified in token.\n\t\n\t      var tokenHeight = token.textHeight = retrieve2( // textHeight should not be inherited, consider it can be specified\n\t      // as box height of the block.\n\t      tokenStyle.textHeight, getLineHeight(font));\n\t      textPadding && (tokenHeight += textPadding[0] + textPadding[2]);\n\t      token.height = tokenHeight;\n\t      token.lineHeight = retrieve3(tokenStyle.textLineHeight, style.textLineHeight, tokenHeight);\n\t      token.textAlign = tokenStyle && tokenStyle.textAlign || style.textAlign;\n\t      token.textVerticalAlign = tokenStyle && tokenStyle.textVerticalAlign || 'middle';\n\t\n\t      if (truncateHeight != null && contentHeight + token.lineHeight > truncateHeight) {\n\t        return {\n\t          lines: [],\n\t          width: 0,\n\t          height: 0\n\t        };\n\t      }\n\t\n\t      token.textWidth = getWidth(token.text, font);\n\t      var tokenWidth = tokenStyle.textWidth;\n\t      var tokenWidthNotSpecified = tokenWidth == null || tokenWidth === 'auto'; // Percent width, can be `100%`, can be used in drawing separate\n\t      // line when box width is needed to be auto.\n\t\n\t      if (typeof tokenWidth === 'string' && tokenWidth.charAt(tokenWidth.length - 1) === '%') {\n\t        token.percentWidth = tokenWidth;\n\t        pendingList.push(token);\n\t        tokenWidth = 0; // Do not truncate in this case, because there is no user case\n\t        // and it is too complicated.\n\t      } else {\n\t        if (tokenWidthNotSpecified) {\n\t          tokenWidth = token.textWidth; // FIXME: If image is not loaded and textWidth is not specified, calling\n\t          // `getBoundingRect()` will not get correct result.\n\t\n\t          var textBackgroundColor = tokenStyle.textBackgroundColor;\n\t          var bgImg = textBackgroundColor && textBackgroundColor.image; // Use cases:\n\t          // (1) If image is not loaded, it will be loaded at render phase and call\n\t          // `dirty()` and `textBackgroundColor.image` will be replaced with the loaded\n\t          // image, and then the right size will be calculated here at the next tick.\n\t          // See `graphic/helper/text.js`.\n\t          // (2) If image loaded, and `textBackgroundColor.image` is image src string,\n\t          // use `imageHelper.findExistImage` to find cached image.\n\t          // `imageHelper.findExistImage` will always be called here before\n\t          // `imageHelper.createOrUpdateImage` in `graphic/helper/text.js#renderRichText`\n\t          // which ensures that image will not be rendered before correct size calcualted.\n\t\n\t          if (bgImg) {\n\t            bgImg = imageHelper.findExistImage(bgImg);\n\t\n\t            if (imageHelper.isImageReady(bgImg)) {\n\t              tokenWidth = Math.max(tokenWidth, bgImg.width * tokenHeight / bgImg.height);\n\t            }\n\t          }\n\t        }\n\t\n\t        var paddingW = textPadding ? textPadding[1] + textPadding[3] : 0;\n\t        tokenWidth += paddingW;\n\t        var remianTruncWidth = truncateWidth != null ? truncateWidth - lineWidth : null;\n\t\n\t        if (remianTruncWidth != null && remianTruncWidth < tokenWidth) {\n\t          if (!tokenWidthNotSpecified || remianTruncWidth < paddingW) {\n\t            token.text = '';\n\t            token.textWidth = tokenWidth = 0;\n\t          } else {\n\t            token.text = truncateText(token.text, remianTruncWidth - paddingW, font, truncate.ellipsis, {\n\t              minChar: truncate.minChar\n\t            });\n\t            token.textWidth = getWidth(token.text, font);\n\t            tokenWidth = token.textWidth + paddingW;\n\t          }\n\t        }\n\t      }\n\t\n\t      lineWidth += token.width = tokenWidth;\n\t      tokenStyle && (lineHeight = Math.max(lineHeight, token.lineHeight));\n\t    }\n\t\n\t    line.width = lineWidth;\n\t    line.lineHeight = lineHeight;\n\t    contentHeight += lineHeight;\n\t    contentWidth = Math.max(contentWidth, lineWidth);\n\t  }\n\t\n\t  contentBlock.outerWidth = contentBlock.width = retrieve2(style.textWidth, contentWidth);\n\t  contentBlock.outerHeight = contentBlock.height = retrieve2(style.textHeight, contentHeight);\n\t\n\t  if (stlPadding) {\n\t    contentBlock.outerWidth += stlPadding[1] + stlPadding[3];\n\t    contentBlock.outerHeight += stlPadding[0] + stlPadding[2];\n\t  }\n\t\n\t  for (var i = 0; i < pendingList.length; i++) {\n\t    var token = pendingList[i];\n\t    var percentWidth = token.percentWidth; // Should not base on outerWidth, because token can not be placed out of padding.\n\t\n\t    token.width = parseInt(percentWidth, 10) / 100 * contentWidth;\n\t  }\n\t\n\t  return contentBlock;\n\t}\n\t\n\tfunction pushTokens(block, str, styleName) {\n\t  var isEmptyStr = str === '';\n\t  var strs = str.split('\\n');\n\t  var lines = block.lines;\n\t\n\t  for (var i = 0; i < strs.length; i++) {\n\t    var text = strs[i];\n\t    var token = {\n\t      styleName: styleName,\n\t      text: text,\n\t      isLineHolder: !text && !isEmptyStr\n\t    }; // The first token should be appended to the last line.\n\t\n\t    if (!i) {\n\t      var tokens = (lines[lines.length - 1] || (lines[0] = {\n\t        tokens: []\n\t      })).tokens; // Consider cases:\n\t      // (1) ''.split('\\n') => ['', '\\n', ''], the '' at the first item\n\t      // (which is a placeholder) should be replaced by new token.\n\t      // (2) A image backage, where token likes {a|}.\n\t      // (3) A redundant '' will affect textAlign in line.\n\t      // (4) tokens with the same tplName should not be merged, because\n\t      // they should be displayed in different box (with border and padding).\n\t\n\t      var tokensLen = tokens.length;\n\t      tokensLen === 1 && tokens[0].isLineHolder ? tokens[0] = token : // Consider text is '', only insert when it is the \"lineHolder\" or\n\t      // \"emptyStr\". Otherwise a redundant '' will affect textAlign in line.\n\t      (text || !tokensLen || isEmptyStr) && tokens.push(token);\n\t    } // Other tokens always start a new line.\n\t    else {\n\t        // If there is '', insert it as a placeholder.\n\t        lines.push({\n\t          tokens: [token]\n\t        });\n\t      }\n\t  }\n\t}\n\t\n\tfunction makeFont(style) {\n\t  // FIXME in node-canvas fontWeight is before fontStyle\n\t  // Use `fontSize` `fontFamily` to check whether font properties are defined.\n\t  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\t  style.fontFamily || 'sans-serif'].join(' ');\n\t  return font && trim(font) || style.textFont || style.font;\n\t}\n\t\n\texports.DEFAULT_FONT = DEFAULT_FONT;\n\texports.$override = $override;\n\texports.getWidth = getWidth;\n\texports.getBoundingRect = getBoundingRect;\n\texports.adjustTextX = adjustTextX;\n\texports.adjustTextY = adjustTextY;\n\texports.adjustTextPositionOnRect = adjustTextPositionOnRect;\n\texports.truncateText = truncateText;\n\texports.getLineHeight = getLineHeight;\n\texports.measureText = measureText;\n\texports.parsePlainText = parsePlainText;\n\texports.parseRichText = parseRichText;\n\texports.makeFont = makeFont;\n\n/***/ },\n/* 18 */\n/***/ function(module, exports) {\n\n\tvar PI2 = Math.PI * 2;\n\t\n\tfunction normalizeRadian(angle) {\n\t  angle %= PI2;\n\t\n\t  if (angle < 0) {\n\t    angle += PI2;\n\t  }\n\t\n\t  return angle;\n\t}\n\t\n\texports.normalizeRadian = normalizeRadian;\n\n/***/ },\n/* 19 */\n/***/ function(module, exports) {\n\n\t// Simple LRU cache use doubly linked list\n\t// @module zrender/core/LRU\n\t\n\t/**\n\t * Simple double linked list. Compared with array, it has O(1) remove operation.\n\t * @constructor\n\t */\n\tvar LinkedList = function () {\n\t  /**\n\t   * @type {module:zrender/core/LRU~Entry}\n\t   */\n\t  this.head = null;\n\t  /**\n\t   * @type {module:zrender/core/LRU~Entry}\n\t   */\n\t\n\t  this.tail = null;\n\t  this._len = 0;\n\t};\n\t\n\tvar linkedListProto = LinkedList.prototype;\n\t/**\n\t * Insert a new value at the tail\n\t * @param  {} val\n\t * @return {module:zrender/core/LRU~Entry}\n\t */\n\t\n\tlinkedListProto.insert = function (val) {\n\t  var entry = new Entry(val);\n\t  this.insertEntry(entry);\n\t  return entry;\n\t};\n\t/**\n\t * Insert an entry at the tail\n\t * @param  {module:zrender/core/LRU~Entry} entry\n\t */\n\t\n\t\n\tlinkedListProto.insertEntry = function (entry) {\n\t  if (!this.head) {\n\t    this.head = this.tail = entry;\n\t  } else {\n\t    this.tail.next = entry;\n\t    entry.prev = this.tail;\n\t    entry.next = null;\n\t    this.tail = entry;\n\t  }\n\t\n\t  this._len++;\n\t};\n\t/**\n\t * Remove entry.\n\t * @param  {module:zrender/core/LRU~Entry} entry\n\t */\n\t\n\t\n\tlinkedListProto.remove = function (entry) {\n\t  var prev = entry.prev;\n\t  var next = entry.next;\n\t\n\t  if (prev) {\n\t    prev.next = next;\n\t  } else {\n\t    // Is head\n\t    this.head = next;\n\t  }\n\t\n\t  if (next) {\n\t    next.prev = prev;\n\t  } else {\n\t    // Is tail\n\t    this.tail = prev;\n\t  }\n\t\n\t  entry.next = entry.prev = null;\n\t  this._len--;\n\t};\n\t/**\n\t * @return {number}\n\t */\n\t\n\t\n\tlinkedListProto.len = function () {\n\t  return this._len;\n\t};\n\t/**\n\t * Clear list\n\t */\n\t\n\t\n\tlinkedListProto.clear = function () {\n\t  this.head = this.tail = null;\n\t  this._len = 0;\n\t};\n\t/**\n\t * @constructor\n\t * @param {} val\n\t */\n\t\n\t\n\tvar Entry = function (val) {\n\t  /**\n\t   * @type {}\n\t   */\n\t  this.value = val;\n\t  /**\n\t   * @type {module:zrender/core/LRU~Entry}\n\t   */\n\t\n\t  this.next;\n\t  /**\n\t   * @type {module:zrender/core/LRU~Entry}\n\t   */\n\t\n\t  this.prev;\n\t};\n\t/**\n\t * LRU Cache\n\t * @constructor\n\t * @alias module:zrender/core/LRU\n\t */\n\t\n\t\n\tvar LRU = function (maxSize) {\n\t  this._list = new LinkedList();\n\t  this._map = {};\n\t  this._maxSize = maxSize || 10;\n\t  this._lastRemovedEntry = null;\n\t};\n\t\n\tvar LRUProto = LRU.prototype;\n\t/**\n\t * @param  {string} key\n\t * @param  {} value\n\t * @return {} Removed value\n\t */\n\t\n\tLRUProto.put = function (key, value) {\n\t  var list = this._list;\n\t  var map = this._map;\n\t  var removed = null;\n\t\n\t  if (map[key] == null) {\n\t    var len = list.len(); // Reuse last removed entry\n\t\n\t    var entry = this._lastRemovedEntry;\n\t\n\t    if (len >= this._maxSize && len > 0) {\n\t      // Remove the least recently used\n\t      var leastUsedEntry = list.head;\n\t      list.remove(leastUsedEntry);\n\t      delete map[leastUsedEntry.key];\n\t      removed = leastUsedEntry.value;\n\t      this._lastRemovedEntry = leastUsedEntry;\n\t    }\n\t\n\t    if (entry) {\n\t      entry.value = value;\n\t    } else {\n\t      entry = new Entry(value);\n\t    }\n\t\n\t    entry.key = key;\n\t    list.insertEntry(entry);\n\t    map[key] = entry;\n\t  }\n\t\n\t  return removed;\n\t};\n\t/**\n\t * @param  {string} key\n\t * @return {}\n\t */\n\t\n\t\n\tLRUProto.get = function (key) {\n\t  var entry = this._map[key];\n\t  var list = this._list;\n\t\n\t  if (entry != null) {\n\t    // Put the latest used entry in the tail\n\t    if (entry !== list.tail) {\n\t      list.remove(entry);\n\t      list.insertEntry(entry);\n\t    }\n\t\n\t    return entry.value;\n\t  }\n\t};\n\t/**\n\t * Clear the cache\n\t */\n\t\n\t\n\tLRUProto.clear = function () {\n\t  this._list.clear();\n\t\n\t  this._map = {};\n\t};\n\t\n\tvar _default = LRU;\n\tmodule.exports = _default;\n\n/***/ },\n/* 20 */\n/***/ function(module, exports) {\n\n\t/**\n\t * @param {Array.<Object>} colorStops\n\t */\n\tvar Gradient = function (colorStops) {\n\t  this.colorStops = colorStops || [];\n\t};\n\t\n\tGradient.prototype = {\n\t  constructor: Gradient,\n\t  addColorStop: function (offset, color) {\n\t    this.colorStops.push({\n\t      offset: offset,\n\t      color: color\n\t    });\n\t  }\n\t};\n\tvar _default = Gradient;\n\tmodule.exports = _default;\n\n/***/ },\n/* 21 */\n/***/ function(module, exports) {\n\n\tvar SHADOW_PROPS = {\n\t  'shadowBlur': 1,\n\t  'shadowOffsetX': 1,\n\t  'shadowOffsetY': 1,\n\t  'textShadowBlur': 1,\n\t  'textShadowOffsetX': 1,\n\t  'textShadowOffsetY': 1,\n\t  'textBoxShadowBlur': 1,\n\t  'textBoxShadowOffsetX': 1,\n\t  'textBoxShadowOffsetY': 1\n\t};\n\t\n\tfunction _default(ctx, propName, value) {\n\t  if (SHADOW_PROPS.hasOwnProperty(propName)) {\n\t    return value *= ctx.dpr;\n\t  }\n\t\n\t  return value;\n\t}\n\t\n\tmodule.exports = _default;\n\n/***/ },\n/* 22 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar smoothSpline = __webpack_require__(59);\n\t\n\tvar smoothBezier = __webpack_require__(58);\n\t\n\tfunction buildPath(ctx, shape, closePath) {\n\t  var points = shape.points;\n\t  var smooth = shape.smooth;\n\t\n\t  if (points && points.length >= 2) {\n\t    if (smooth && smooth !== 'spline') {\n\t      var controlPoints = smoothBezier(points, smooth, closePath, shape.smoothConstraint);\n\t      ctx.moveTo(points[0][0], points[0][1]);\n\t      var len = points.length;\n\t\n\t      for (var i = 0; i < (closePath ? len : len - 1); i++) {\n\t        var cp1 = controlPoints[i * 2];\n\t        var cp2 = controlPoints[i * 2 + 1];\n\t        var p = points[(i + 1) % len];\n\t        ctx.bezierCurveTo(cp1[0], cp1[1], cp2[0], cp2[1], p[0], p[1]);\n\t      }\n\t    } else {\n\t      if (smooth === 'spline') {\n\t        points = smoothSpline(points, closePath);\n\t      }\n\t\n\t      ctx.moveTo(points[0][0], points[0][1]);\n\t\n\t      for (var i = 1, l = points.length; i < l; i++) {\n\t        ctx.lineTo(points[i][0], points[i][1]);\n\t      }\n\t    }\n\t\n\t    closePath && ctx.closePath();\n\t  }\n\t}\n\t\n\texports.buildPath = buildPath;\n\n/***/ },\n/* 23 */\n/***/ function(module, exports) {\n\n\tfunction buildPath(ctx, shape) {\n\t  var x = shape.x;\n\t  var y = shape.y;\n\t  var width = shape.width;\n\t  var height = shape.height;\n\t  var r = shape.r;\n\t  var r1;\n\t  var r2;\n\t  var r3;\n\t  var r4; // Convert width and height to positive for better borderRadius\n\t\n\t  if (width < 0) {\n\t    x = x + width;\n\t    width = -width;\n\t  }\n\t\n\t  if (height < 0) {\n\t    y = y + height;\n\t    height = -height;\n\t  }\n\t\n\t  if (typeof r === 'number') {\n\t    r1 = r2 = r3 = r4 = r;\n\t  } else if (r instanceof Array) {\n\t    if (r.length === 1) {\n\t      r1 = r2 = r3 = r4 = r[0];\n\t    } else if (r.length === 2) {\n\t      r1 = r3 = r[0];\n\t      r2 = r4 = r[1];\n\t    } else if (r.length === 3) {\n\t      r1 = r[0];\n\t      r2 = r4 = r[1];\n\t      r3 = r[2];\n\t    } else {\n\t      r1 = r[0];\n\t      r2 = r[1];\n\t      r3 = r[2];\n\t      r4 = r[3];\n\t    }\n\t  } else {\n\t    r1 = r2 = r3 = r4 = 0;\n\t  }\n\t\n\t  var total;\n\t\n\t  if (r1 + r2 > width) {\n\t    total = r1 + r2;\n\t    r1 *= width / total;\n\t    r2 *= width / total;\n\t  }\n\t\n\t  if (r3 + r4 > width) {\n\t    total = r3 + r4;\n\t    r3 *= width / total;\n\t    r4 *= width / total;\n\t  }\n\t\n\t  if (r2 + r3 > height) {\n\t    total = r2 + r3;\n\t    r2 *= height / total;\n\t    r3 *= height / total;\n\t  }\n\t\n\t  if (r1 + r4 > height) {\n\t    total = r1 + r4;\n\t    r1 *= height / total;\n\t    r4 *= height / total;\n\t  }\n\t\n\t  ctx.moveTo(x + r1, y);\n\t  ctx.lineTo(x + width - r2, y);\n\t  r2 !== 0 && ctx.quadraticCurveTo(x + width, y, x + width, y + r2);\n\t  ctx.lineTo(x + width, y + height - r3);\n\t  r3 !== 0 && ctx.quadraticCurveTo(x + width, y + height, x + width - r3, y + height);\n\t  ctx.lineTo(x + r4, y + height);\n\t  r4 !== 0 && ctx.quadraticCurveTo(x, y + height, x, y + height - r4);\n\t  ctx.lineTo(x, y + r1);\n\t  r1 !== 0 && ctx.quadraticCurveTo(x, y, x + r1, y);\n\t}\n\t\n\texports.buildPath = buildPath;\n\n/***/ },\n/* 24 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar _util = __webpack_require__(1);\n\t\n\tvar retrieve2 = _util.retrieve2;\n\tvar retrieve3 = _util.retrieve3;\n\tvar each = _util.each;\n\tvar normalizeCssArray = _util.normalizeCssArray;\n\tvar isString = _util.isString;\n\tvar isObject = _util.isObject;\n\t\n\tvar textContain = __webpack_require__(17);\n\t\n\tvar roundRectHelper = __webpack_require__(23);\n\t\n\tvar imageHelper = __webpack_require__(11);\n\t\n\tvar fixShadow = __webpack_require__(21);\n\t\n\t// TODO: Have not support 'start', 'end' yet.\n\tvar VALID_TEXT_ALIGN = {\n\t  left: 1,\n\t  right: 1,\n\t  center: 1\n\t};\n\tvar VALID_TEXT_VERTICAL_ALIGN = {\n\t  top: 1,\n\t  bottom: 1,\n\t  middle: 1\n\t};\n\t/**\n\t * @param {module:zrender/graphic/Style} style\n\t * @return {module:zrender/graphic/Style} The input style.\n\t */\n\t\n\tfunction normalizeTextStyle(style) {\n\t  normalizeStyle(style);\n\t  each(style.rich, normalizeStyle);\n\t  return style;\n\t}\n\t\n\tfunction normalizeStyle(style) {\n\t  if (style) {\n\t    style.font = textContain.makeFont(style);\n\t    var textAlign = style.textAlign;\n\t    textAlign === 'middle' && (textAlign = 'center');\n\t    style.textAlign = textAlign == null || VALID_TEXT_ALIGN[textAlign] ? textAlign : 'left'; // Compatible with textBaseline.\n\t\n\t    var textVerticalAlign = style.textVerticalAlign || style.textBaseline;\n\t    textVerticalAlign === 'center' && (textVerticalAlign = 'middle');\n\t    style.textVerticalAlign = textVerticalAlign == null || VALID_TEXT_VERTICAL_ALIGN[textVerticalAlign] ? textVerticalAlign : 'top';\n\t    var textPadding = style.textPadding;\n\t\n\t    if (textPadding) {\n\t      style.textPadding = normalizeCssArray(style.textPadding);\n\t    }\n\t  }\n\t}\n\t/**\n\t * @param {CanvasRenderingContext2D} ctx\n\t * @param {string} text\n\t * @param {module:zrender/graphic/Style} style\n\t * @param {Object|boolean} [rect] {x, y, width, height}\n\t *                  If set false, rect text is not used.\n\t */\n\t\n\t\n\tfunction renderText(hostEl, ctx, text, style, rect) {\n\t  style.rich ? renderRichText(hostEl, ctx, text, style, rect) : renderPlainText(hostEl, ctx, text, style, rect);\n\t}\n\t\n\tfunction renderPlainText(hostEl, ctx, text, style, rect) {\n\t  var font = setCtx(ctx, 'font', style.font || textContain.DEFAULT_FONT);\n\t  var textPadding = style.textPadding;\n\t  var contentBlock = hostEl.__textCotentBlock;\n\t\n\t  if (!contentBlock || hostEl.__dirty) {\n\t    contentBlock = hostEl.__textCotentBlock = textContain.parsePlainText(text, font, textPadding, style.truncate);\n\t  }\n\t\n\t  var outerHeight = contentBlock.outerHeight;\n\t  var textLines = contentBlock.lines;\n\t  var lineHeight = contentBlock.lineHeight;\n\t  var boxPos = getBoxPosition(outerHeight, style, rect);\n\t  var baseX = boxPos.baseX;\n\t  var baseY = boxPos.baseY;\n\t  var textAlign = boxPos.textAlign;\n\t  var textVerticalAlign = boxPos.textVerticalAlign; // Origin of textRotation should be the base point of text drawing.\n\t\n\t  applyTextRotation(ctx, style, rect, baseX, baseY);\n\t  var boxY = textContain.adjustTextY(baseY, outerHeight, textVerticalAlign);\n\t  var textX = baseX;\n\t  var textY = boxY;\n\t  var needDrawBg = needDrawBackground(style);\n\t\n\t  if (needDrawBg || textPadding) {\n\t    // Consider performance, do not call getTextWidth util necessary.\n\t    var textWidth = textContain.getWidth(text, font);\n\t    var outerWidth = textWidth;\n\t    textPadding && (outerWidth += textPadding[1] + textPadding[3]);\n\t    var boxX = textContain.adjustTextX(baseX, outerWidth, textAlign);\n\t    needDrawBg && drawBackground(hostEl, ctx, style, boxX, boxY, outerWidth, outerHeight);\n\t\n\t    if (textPadding) {\n\t      textX = getTextXForPadding(baseX, textAlign, textPadding);\n\t      textY += textPadding[0];\n\t    }\n\t  }\n\t\n\t  setCtx(ctx, 'textAlign', textAlign || 'left'); // Force baseline to be \"middle\". Otherwise, if using \"top\", the\n\t  // text will offset downward a little bit in font \"Microsoft YaHei\".\n\t\n\t  setCtx(ctx, 'textBaseline', 'middle'); // Always set shadowBlur and shadowOffset to avoid leak from displayable.\n\t\n\t  setCtx(ctx, 'shadowBlur', style.textShadowBlur || 0);\n\t  setCtx(ctx, 'shadowColor', style.textShadowColor || 'transparent');\n\t  setCtx(ctx, 'shadowOffsetX', style.textShadowOffsetX || 0);\n\t  setCtx(ctx, 'shadowOffsetY', style.textShadowOffsetY || 0); // `textBaseline` is set as 'middle'.\n\t\n\t  textY += lineHeight / 2;\n\t  var textStrokeWidth = style.textStrokeWidth;\n\t  var textStroke = getStroke(style.textStroke, textStrokeWidth);\n\t  var textFill = getFill(style.textFill);\n\t\n\t  if (textStroke) {\n\t    setCtx(ctx, 'lineWidth', textStrokeWidth);\n\t    setCtx(ctx, 'strokeStyle', textStroke);\n\t  }\n\t\n\t  if (textFill) {\n\t    setCtx(ctx, 'fillStyle', textFill);\n\t  }\n\t\n\t  for (var i = 0; i < textLines.length; i++) {\n\t    // Fill after stroke so the outline will not cover the main part.\n\t    textStroke && ctx.strokeText(textLines[i], textX, textY);\n\t    textFill && ctx.fillText(textLines[i], textX, textY);\n\t    textY += lineHeight;\n\t  }\n\t}\n\t\n\tfunction renderRichText(hostEl, ctx, text, style, rect) {\n\t  var contentBlock = hostEl.__textCotentBlock;\n\t\n\t  if (!contentBlock || hostEl.__dirty) {\n\t    contentBlock = hostEl.__textCotentBlock = textContain.parseRichText(text, style);\n\t  }\n\t\n\t  drawRichText(hostEl, ctx, contentBlock, style, rect);\n\t}\n\t\n\tfunction drawRichText(hostEl, ctx, contentBlock, style, rect) {\n\t  var contentWidth = contentBlock.width;\n\t  var outerWidth = contentBlock.outerWidth;\n\t  var outerHeight = contentBlock.outerHeight;\n\t  var textPadding = style.textPadding;\n\t  var boxPos = getBoxPosition(outerHeight, style, rect);\n\t  var baseX = boxPos.baseX;\n\t  var baseY = boxPos.baseY;\n\t  var textAlign = boxPos.textAlign;\n\t  var textVerticalAlign = boxPos.textVerticalAlign; // Origin of textRotation should be the base point of text drawing.\n\t\n\t  applyTextRotation(ctx, style, rect, baseX, baseY);\n\t  var boxX = textContain.adjustTextX(baseX, outerWidth, textAlign);\n\t  var boxY = textContain.adjustTextY(baseY, outerHeight, textVerticalAlign);\n\t  var xLeft = boxX;\n\t  var lineTop = boxY;\n\t\n\t  if (textPadding) {\n\t    xLeft += textPadding[3];\n\t    lineTop += textPadding[0];\n\t  }\n\t\n\t  var xRight = xLeft + contentWidth;\n\t  needDrawBackground(style) && drawBackground(hostEl, ctx, style, boxX, boxY, outerWidth, outerHeight);\n\t\n\t  for (var i = 0; i < contentBlock.lines.length; i++) {\n\t    var line = contentBlock.lines[i];\n\t    var tokens = line.tokens;\n\t    var tokenCount = tokens.length;\n\t    var lineHeight = line.lineHeight;\n\t    var usedWidth = line.width;\n\t    var leftIndex = 0;\n\t    var lineXLeft = xLeft;\n\t    var lineXRight = xRight;\n\t    var rightIndex = tokenCount - 1;\n\t    var token;\n\t\n\t    while (leftIndex < tokenCount && (token = tokens[leftIndex], !token.textAlign || token.textAlign === 'left')) {\n\t      placeToken(hostEl, ctx, token, style, lineHeight, lineTop, lineXLeft, 'left');\n\t      usedWidth -= token.width;\n\t      lineXLeft += token.width;\n\t      leftIndex++;\n\t    }\n\t\n\t    while (rightIndex >= 0 && (token = tokens[rightIndex], token.textAlign === 'right')) {\n\t      placeToken(hostEl, ctx, token, style, lineHeight, lineTop, lineXRight, 'right');\n\t      usedWidth -= token.width;\n\t      lineXRight -= token.width;\n\t      rightIndex--;\n\t    } // The other tokens are placed as textAlign 'center' if there is enough space.\n\t\n\t\n\t    lineXLeft += (contentWidth - (lineXLeft - xLeft) - (xRight - lineXRight) - usedWidth) / 2;\n\t\n\t    while (leftIndex <= rightIndex) {\n\t      token = tokens[leftIndex]; // Consider width specified by user, use 'center' rather than 'left'.\n\t\n\t      placeToken(hostEl, ctx, token, style, lineHeight, lineTop, lineXLeft + token.width / 2, 'center');\n\t      lineXLeft += token.width;\n\t      leftIndex++;\n\t    }\n\t\n\t    lineTop += lineHeight;\n\t  }\n\t}\n\t\n\tfunction applyTextRotation(ctx, style, rect, x, y) {\n\t  // textRotation only apply in RectText.\n\t  if (rect && style.textRotation) {\n\t    var origin = style.textOrigin;\n\t\n\t    if (origin === 'center') {\n\t      x = rect.width / 2 + rect.x;\n\t      y = rect.height / 2 + rect.y;\n\t    } else if (origin) {\n\t      x = origin[0] + rect.x;\n\t      y = origin[1] + rect.y;\n\t    }\n\t\n\t    ctx.translate(x, y); // Positive: anticlockwise\n\t\n\t    ctx.rotate(-style.textRotation);\n\t    ctx.translate(-x, -y);\n\t  }\n\t}\n\t\n\tfunction placeToken(hostEl, ctx, token, style, lineHeight, lineTop, x, textAlign) {\n\t  var tokenStyle = style.rich[token.styleName] || {}; // 'ctx.textBaseline' is always set as 'middle', for sake of\n\t  // the bias of \"Microsoft YaHei\".\n\t\n\t  var textVerticalAlign = token.textVerticalAlign;\n\t  var y = lineTop + lineHeight / 2;\n\t\n\t  if (textVerticalAlign === 'top') {\n\t    y = lineTop + token.height / 2;\n\t  } else if (textVerticalAlign === 'bottom') {\n\t    y = lineTop + lineHeight - token.height / 2;\n\t  }\n\t\n\t  !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\t  var textPadding = token.textPadding;\n\t\n\t  if (textPadding) {\n\t    x = getTextXForPadding(x, textAlign, textPadding);\n\t    y -= token.height / 2 - textPadding[2] - token.textHeight / 2;\n\t  }\n\t\n\t  setCtx(ctx, 'shadowBlur', retrieve3(tokenStyle.textShadowBlur, style.textShadowBlur, 0));\n\t  setCtx(ctx, 'shadowColor', tokenStyle.textShadowColor || style.textShadowColor || 'transparent');\n\t  setCtx(ctx, 'shadowOffsetX', retrieve3(tokenStyle.textShadowOffsetX, style.textShadowOffsetX, 0));\n\t  setCtx(ctx, 'shadowOffsetY', retrieve3(tokenStyle.textShadowOffsetY, style.textShadowOffsetY, 0));\n\t  setCtx(ctx, 'textAlign', textAlign); // Force baseline to be \"middle\". Otherwise, if using \"top\", the\n\t  // text will offset downward a little bit in font \"Microsoft YaHei\".\n\t\n\t  setCtx(ctx, 'textBaseline', 'middle');\n\t  setCtx(ctx, 'font', token.font || textContain.DEFAULT_FONT);\n\t  var textStroke = getStroke(tokenStyle.textStroke || style.textStroke, textStrokeWidth);\n\t  var textFill = getFill(tokenStyle.textFill || style.textFill);\n\t  var textStrokeWidth = retrieve2(tokenStyle.textStrokeWidth, style.textStrokeWidth); // Fill after stroke so the outline will not cover the main part.\n\t\n\t  if (textStroke) {\n\t    setCtx(ctx, 'lineWidth', textStrokeWidth);\n\t    setCtx(ctx, 'strokeStyle', textStroke);\n\t    ctx.strokeText(token.text, x, y);\n\t  }\n\t\n\t  if (textFill) {\n\t    setCtx(ctx, 'fillStyle', textFill);\n\t    ctx.fillText(token.text, x, y);\n\t  }\n\t}\n\t\n\tfunction needDrawBackground(style) {\n\t  return style.textBackgroundColor || style.textBorderWidth && style.textBorderColor;\n\t} // style: {textBackgroundColor, textBorderWidth, textBorderColor, textBorderRadius}\n\t// shape: {x, y, width, height}\n\t\n\t\n\tfunction drawBackground(hostEl, ctx, style, x, y, width, height) {\n\t  var textBackgroundColor = style.textBackgroundColor;\n\t  var textBorderWidth = style.textBorderWidth;\n\t  var textBorderColor = style.textBorderColor;\n\t  var isPlainBg = isString(textBackgroundColor);\n\t  setCtx(ctx, 'shadowBlur', style.textBoxShadowBlur || 0);\n\t  setCtx(ctx, 'shadowColor', style.textBoxShadowColor || 'transparent');\n\t  setCtx(ctx, 'shadowOffsetX', style.textBoxShadowOffsetX || 0);\n\t  setCtx(ctx, 'shadowOffsetY', style.textBoxShadowOffsetY || 0);\n\t\n\t  if (isPlainBg || textBorderWidth && textBorderColor) {\n\t    ctx.beginPath();\n\t    var textBorderRadius = style.textBorderRadius;\n\t\n\t    if (!textBorderRadius) {\n\t      ctx.rect(x, y, width, height);\n\t    } else {\n\t      roundRectHelper.buildPath(ctx, {\n\t        x: x,\n\t        y: y,\n\t        width: width,\n\t        height: height,\n\t        r: textBorderRadius\n\t      });\n\t    }\n\t\n\t    ctx.closePath();\n\t  }\n\t\n\t  if (isPlainBg) {\n\t    setCtx(ctx, 'fillStyle', textBackgroundColor);\n\t    ctx.fill();\n\t  } else if (isObject(textBackgroundColor)) {\n\t    var image = textBackgroundColor.image;\n\t    image = imageHelper.createOrUpdateImage(image, null, hostEl, onBgImageLoaded, textBackgroundColor);\n\t\n\t    if (image && imageHelper.isImageReady(image)) {\n\t      ctx.drawImage(image, x, y, width, height);\n\t    }\n\t  }\n\t\n\t  if (textBorderWidth && textBorderColor) {\n\t    setCtx(ctx, 'lineWidth', textBorderWidth);\n\t    setCtx(ctx, 'strokeStyle', textBorderColor);\n\t    ctx.stroke();\n\t  }\n\t}\n\t\n\tfunction onBgImageLoaded(image, textBackgroundColor) {\n\t  // Replace image, so that `contain/text.js#parseRichText`\n\t  // will get correct result in next tick.\n\t  textBackgroundColor.image = image;\n\t}\n\t\n\tfunction getBoxPosition(blockHeiht, style, rect) {\n\t  var baseX = style.x || 0;\n\t  var baseY = style.y || 0;\n\t  var textAlign = style.textAlign;\n\t  var textVerticalAlign = style.textVerticalAlign; // Text position represented by coord\n\t\n\t  if (rect) {\n\t    var textPosition = style.textPosition;\n\t\n\t    if (textPosition instanceof Array) {\n\t      // Percent\n\t      baseX = rect.x + parsePercent(textPosition[0], rect.width);\n\t      baseY = rect.y + parsePercent(textPosition[1], rect.height);\n\t    } else {\n\t      var res = textContain.adjustTextPositionOnRect(textPosition, rect, style.textDistance);\n\t      baseX = res.x;\n\t      baseY = res.y; // Default align and baseline when has textPosition\n\t\n\t      textAlign = textAlign || res.textAlign;\n\t      textVerticalAlign = textVerticalAlign || res.textVerticalAlign;\n\t    } // textOffset is only support in RectText, otherwise\n\t    // we have to adjust boundingRect for textOffset.\n\t\n\t\n\t    var textOffset = style.textOffset;\n\t\n\t    if (textOffset) {\n\t      baseX += textOffset[0];\n\t      baseY += textOffset[1];\n\t    }\n\t  }\n\t\n\t  return {\n\t    baseX: baseX,\n\t    baseY: baseY,\n\t    textAlign: textAlign,\n\t    textVerticalAlign: textVerticalAlign\n\t  };\n\t}\n\t\n\tfunction setCtx(ctx, prop, value) {\n\t  ctx[prop] = fixShadow(ctx, prop, value);\n\t  return ctx[prop];\n\t}\n\t/**\n\t * @param {string} [stroke] If specified, do not check style.textStroke.\n\t * @param {string} [lineWidth] If specified, do not check style.textStroke.\n\t * @param {number} style\n\t */\n\t\n\t\n\tfunction getStroke(stroke, lineWidth) {\n\t  return stroke == null || lineWidth <= 0 || stroke === 'transparent' || stroke === 'none' ? null // TODO pattern and gradient?\n\t  : stroke.image || stroke.colorStops ? '#000' : stroke;\n\t}\n\t\n\tfunction getFill(fill) {\n\t  return fill == null || fill === 'none' ? null // TODO pattern and gradient?\n\t  : fill.image || fill.colorStops ? '#000' : fill;\n\t}\n\t\n\tfunction parsePercent(value, maxValue) {\n\t  if (typeof value === 'string') {\n\t    if (value.lastIndexOf('%') >= 0) {\n\t      return parseFloat(value) / 100 * maxValue;\n\t    }\n\t\n\t    return parseFloat(value);\n\t  }\n\t\n\t  return value;\n\t}\n\t\n\tfunction getTextXForPadding(x, textAlign, textPadding) {\n\t  return textAlign === 'right' ? x - textPadding[1] : textAlign === 'center' ? x + textPadding[3] / 2 - textPadding[1] / 2 : x + textPadding[3];\n\t}\n\t/**\n\t * @param {string} text\n\t * @param {module:zrender/Style} style\n\t * @return {boolean}\n\t */\n\t\n\t\n\tfunction needDrawText(text, style) {\n\t  return text != null && (text || style.textBackgroundColor || style.textBorderWidth && style.textBorderColor || style.textPadding);\n\t}\n\t\n\texports.normalizeTextStyle = normalizeTextStyle;\n\texports.renderText = renderText;\n\texports.getStroke = getStroke;\n\texports.getFill = getFill;\n\texports.needDrawText = needDrawText;\n\n/***/ },\n/* 25 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar matrix = __webpack_require__(10);\n\t\n\tvar vector = __webpack_require__(3);\n\t\n\t/**\n\t * 提供变换扩展\n\t * @module zrender/mixin/Transformable\n\t * @author pissang (https://www.github.com/pissang)\n\t */\n\tvar mIdentity = matrix.identity;\n\tvar EPSILON = 5e-5;\n\t\n\tfunction isNotAroundZero(val) {\n\t  return val > EPSILON || val < -EPSILON;\n\t}\n\t/**\n\t * @alias module:zrender/mixin/Transformable\n\t * @constructor\n\t */\n\t\n\t\n\tvar Transformable = function (opts) {\n\t  opts = opts || {}; // If there are no given position, rotation, scale\n\t\n\t  if (!opts.position) {\n\t    /**\n\t     * 平移\n\t     * @type {Array.<number>}\n\t     * @default [0, 0]\n\t     */\n\t    this.position = [0, 0];\n\t  }\n\t\n\t  if (opts.rotation == null) {\n\t    /**\n\t     * 旋转\n\t     * @type {Array.<number>}\n\t     * @default 0\n\t     */\n\t    this.rotation = 0;\n\t  }\n\t\n\t  if (!opts.scale) {\n\t    /**\n\t     * 缩放\n\t     * @type {Array.<number>}\n\t     * @default [1, 1]\n\t     */\n\t    this.scale = [1, 1];\n\t  }\n\t  /**\n\t   * 旋转和缩放的原点\n\t   * @type {Array.<number>}\n\t   * @default null\n\t   */\n\t\n\t\n\t  this.origin = this.origin || null;\n\t};\n\t\n\tvar transformableProto = Transformable.prototype;\n\ttransformableProto.transform = null;\n\t/**\n\t * 判断是否需要有坐标变换\n\t * 如果有坐标变换, 则从position, rotation, scale以及父节点的transform计算出自身的transform矩阵\n\t */\n\t\n\ttransformableProto.needLocalTransform = function () {\n\t  return isNotAroundZero(this.rotation) || isNotAroundZero(this.position[0]) || isNotAroundZero(this.position[1]) || isNotAroundZero(this.scale[0] - 1) || isNotAroundZero(this.scale[1] - 1);\n\t};\n\t\n\ttransformableProto.updateTransform = function () {\n\t  var parent = this.parent;\n\t  var parentHasTransform = parent && parent.transform;\n\t  var needLocalTransform = this.needLocalTransform();\n\t  var m = this.transform;\n\t\n\t  if (!(needLocalTransform || parentHasTransform)) {\n\t    m && mIdentity(m);\n\t    return;\n\t  }\n\t\n\t  m = m || matrix.create();\n\t\n\t  if (needLocalTransform) {\n\t    this.getLocalTransform(m);\n\t  } else {\n\t    mIdentity(m);\n\t  } // 应用父节点变换\n\t\n\t\n\t  if (parentHasTransform) {\n\t    if (needLocalTransform) {\n\t      matrix.mul(m, parent.transform, m);\n\t    } else {\n\t      matrix.copy(m, parent.transform);\n\t    }\n\t  } // 保存这个变换矩阵\n\t\n\t\n\t  this.transform = m;\n\t  this.invTransform = this.invTransform || matrix.create();\n\t  matrix.invert(this.invTransform, m);\n\t};\n\t\n\ttransformableProto.getLocalTransform = function (m) {\n\t  return Transformable.getLocalTransform(this, m);\n\t};\n\t/**\n\t * 将自己的transform应用到context上\n\t * @param {CanvasRenderingContext2D} ctx\n\t */\n\t\n\t\n\ttransformableProto.setTransform = function (ctx) {\n\t  var m = this.transform;\n\t  var dpr = ctx.dpr || 1;\n\t\n\t  if (m) {\n\t    ctx.setTransform(dpr * m[0], dpr * m[1], dpr * m[2], dpr * m[3], dpr * m[4], dpr * m[5]);\n\t  } else {\n\t    ctx.setTransform(dpr, 0, 0, dpr, 0, 0);\n\t  }\n\t};\n\t\n\ttransformableProto.restoreTransform = function (ctx) {\n\t  var dpr = ctx.dpr || 1;\n\t  ctx.setTransform(dpr, 0, 0, dpr, 0, 0);\n\t};\n\t\n\tvar tmpTransform = [];\n\t/**\n\t * 分解`transform`矩阵到`position`, `rotation`, `scale`\n\t */\n\t\n\ttransformableProto.decomposeTransform = function () {\n\t  if (!this.transform) {\n\t    return;\n\t  }\n\t\n\t  var parent = this.parent;\n\t  var m = this.transform;\n\t\n\t  if (parent && parent.transform) {\n\t    // Get local transform and decompose them to position, scale, rotation\n\t    matrix.mul(tmpTransform, parent.invTransform, m);\n\t    m = tmpTransform;\n\t  }\n\t\n\t  var sx = m[0] * m[0] + m[1] * m[1];\n\t  var sy = m[2] * m[2] + m[3] * m[3];\n\t  var position = this.position;\n\t  var scale = this.scale;\n\t\n\t  if (isNotAroundZero(sx - 1)) {\n\t    sx = Math.sqrt(sx);\n\t  }\n\t\n\t  if (isNotAroundZero(sy - 1)) {\n\t    sy = Math.sqrt(sy);\n\t  }\n\t\n\t  if (m[0] < 0) {\n\t    sx = -sx;\n\t  }\n\t\n\t  if (m[3] < 0) {\n\t    sy = -sy;\n\t  }\n\t\n\t  position[0] = m[4];\n\t  position[1] = m[5];\n\t  scale[0] = sx;\n\t  scale[1] = sy;\n\t  this.rotation = Math.atan2(-m[1] / sy, m[0] / sx);\n\t};\n\t/**\n\t * Get global scale\n\t * @return {Array.<number>}\n\t */\n\t\n\t\n\ttransformableProto.getGlobalScale = function () {\n\t  var m = this.transform;\n\t\n\t  if (!m) {\n\t    return [1, 1];\n\t  }\n\t\n\t  var sx = Math.sqrt(m[0] * m[0] + m[1] * m[1]);\n\t  var sy = Math.sqrt(m[2] * m[2] + m[3] * m[3]);\n\t\n\t  if (m[0] < 0) {\n\t    sx = -sx;\n\t  }\n\t\n\t  if (m[3] < 0) {\n\t    sy = -sy;\n\t  }\n\t\n\t  return [sx, sy];\n\t};\n\t/**\n\t * 变换坐标位置到 shape 的局部坐标空间\n\t * @method\n\t * @param {number} x\n\t * @param {number} y\n\t * @return {Array.<number>}\n\t */\n\t\n\t\n\ttransformableProto.transformCoordToLocal = function (x, y) {\n\t  var v2 = [x, y];\n\t  var invTransform = this.invTransform;\n\t\n\t  if (invTransform) {\n\t    vector.applyTransform(v2, v2, invTransform);\n\t  }\n\t\n\t  return v2;\n\t};\n\t/**\n\t * 变换局部坐标位置到全局坐标空间\n\t * @method\n\t * @param {number} x\n\t * @param {number} y\n\t * @return {Array.<number>}\n\t */\n\t\n\t\n\ttransformableProto.transformCoordToGlobal = function (x, y) {\n\t  var v2 = [x, y];\n\t  var transform = this.transform;\n\t\n\t  if (transform) {\n\t    vector.applyTransform(v2, v2, transform);\n\t  }\n\t\n\t  return v2;\n\t};\n\t/**\n\t * @static\n\t * @param {Object} target\n\t * @param {Array.<number>} target.origin\n\t * @param {number} target.rotation\n\t * @param {Array.<number>} target.position\n\t * @param {Array.<number>} [m]\n\t */\n\t\n\t\n\tTransformable.getLocalTransform = function (target, m) {\n\t  m = m || [];\n\t  mIdentity(m);\n\t  var origin = target.origin;\n\t  var scale = target.scale || [1, 1];\n\t  var rotation = target.rotation || 0;\n\t  var position = target.position || [0, 0];\n\t\n\t  if (origin) {\n\t    // Translate to origin\n\t    m[4] -= origin[0];\n\t    m[5] -= origin[1];\n\t  }\n\t\n\t  matrix.scale(m, m, scale);\n\t\n\t  if (rotation) {\n\t    matrix.rotate(m, m, rotation);\n\t  }\n\t\n\t  if (origin) {\n\t    // Translate back from origin\n\t    m[4] += origin[0];\n\t    m[5] += origin[1];\n\t  }\n\t\n\t  m[4] += position[0];\n\t  m[5] += position[1];\n\t  return m;\n\t};\n\t\n\tvar _default = Transformable;\n\tmodule.exports = _default;\n\n/***/ },\n/* 26 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar LRU = __webpack_require__(19);\n\t\n\tvar kCSSColorTable = {\n\t  'transparent': [0, 0, 0, 0],\n\t  'aliceblue': [240, 248, 255, 1],\n\t  'antiquewhite': [250, 235, 215, 1],\n\t  'aqua': [0, 255, 255, 1],\n\t  'aquamarine': [127, 255, 212, 1],\n\t  'azure': [240, 255, 255, 1],\n\t  'beige': [245, 245, 220, 1],\n\t  'bisque': [255, 228, 196, 1],\n\t  'black': [0, 0, 0, 1],\n\t  'blanchedalmond': [255, 235, 205, 1],\n\t  'blue': [0, 0, 255, 1],\n\t  'blueviolet': [138, 43, 226, 1],\n\t  'brown': [165, 42, 42, 1],\n\t  'burlywood': [222, 184, 135, 1],\n\t  'cadetblue': [95, 158, 160, 1],\n\t  'chartreuse': [127, 255, 0, 1],\n\t  'chocolate': [210, 105, 30, 1],\n\t  'coral': [255, 127, 80, 1],\n\t  'cornflowerblue': [100, 149, 237, 1],\n\t  'cornsilk': [255, 248, 220, 1],\n\t  'crimson': [220, 20, 60, 1],\n\t  'cyan': [0, 255, 255, 1],\n\t  'darkblue': [0, 0, 139, 1],\n\t  'darkcyan': [0, 139, 139, 1],\n\t  'darkgoldenrod': [184, 134, 11, 1],\n\t  'darkgray': [169, 169, 169, 1],\n\t  'darkgreen': [0, 100, 0, 1],\n\t  'darkgrey': [169, 169, 169, 1],\n\t  'darkkhaki': [189, 183, 107, 1],\n\t  'darkmagenta': [139, 0, 139, 1],\n\t  'darkolivegreen': [85, 107, 47, 1],\n\t  'darkorange': [255, 140, 0, 1],\n\t  'darkorchid': [153, 50, 204, 1],\n\t  'darkred': [139, 0, 0, 1],\n\t  'darksalmon': [233, 150, 122, 1],\n\t  'darkseagreen': [143, 188, 143, 1],\n\t  'darkslateblue': [72, 61, 139, 1],\n\t  'darkslategray': [47, 79, 79, 1],\n\t  'darkslategrey': [47, 79, 79, 1],\n\t  'darkturquoise': [0, 206, 209, 1],\n\t  'darkviolet': [148, 0, 211, 1],\n\t  'deeppink': [255, 20, 147, 1],\n\t  'deepskyblue': [0, 191, 255, 1],\n\t  'dimgray': [105, 105, 105, 1],\n\t  'dimgrey': [105, 105, 105, 1],\n\t  'dodgerblue': [30, 144, 255, 1],\n\t  'firebrick': [178, 34, 34, 1],\n\t  'floralwhite': [255, 250, 240, 1],\n\t  'forestgreen': [34, 139, 34, 1],\n\t  'fuchsia': [255, 0, 255, 1],\n\t  'gainsboro': [220, 220, 220, 1],\n\t  'ghostwhite': [248, 248, 255, 1],\n\t  'gold': [255, 215, 0, 1],\n\t  'goldenrod': [218, 165, 32, 1],\n\t  'gray': [128, 128, 128, 1],\n\t  'green': [0, 128, 0, 1],\n\t  'greenyellow': [173, 255, 47, 1],\n\t  'grey': [128, 128, 128, 1],\n\t  'honeydew': [240, 255, 240, 1],\n\t  'hotpink': [255, 105, 180, 1],\n\t  'indianred': [205, 92, 92, 1],\n\t  'indigo': [75, 0, 130, 1],\n\t  'ivory': [255, 255, 240, 1],\n\t  'khaki': [240, 230, 140, 1],\n\t  'lavender': [230, 230, 250, 1],\n\t  'lavenderblush': [255, 240, 245, 1],\n\t  'lawngreen': [124, 252, 0, 1],\n\t  'lemonchiffon': [255, 250, 205, 1],\n\t  'lightblue': [173, 216, 230, 1],\n\t  'lightcoral': [240, 128, 128, 1],\n\t  'lightcyan': [224, 255, 255, 1],\n\t  'lightgoldenrodyellow': [250, 250, 210, 1],\n\t  'lightgray': [211, 211, 211, 1],\n\t  'lightgreen': [144, 238, 144, 1],\n\t  'lightgrey': [211, 211, 211, 1],\n\t  'lightpink': [255, 182, 193, 1],\n\t  'lightsalmon': [255, 160, 122, 1],\n\t  'lightseagreen': [32, 178, 170, 1],\n\t  'lightskyblue': [135, 206, 250, 1],\n\t  'lightslategray': [119, 136, 153, 1],\n\t  'lightslategrey': [119, 136, 153, 1],\n\t  'lightsteelblue': [176, 196, 222, 1],\n\t  'lightyellow': [255, 255, 224, 1],\n\t  'lime': [0, 255, 0, 1],\n\t  'limegreen': [50, 205, 50, 1],\n\t  'linen': [250, 240, 230, 1],\n\t  'magenta': [255, 0, 255, 1],\n\t  'maroon': [128, 0, 0, 1],\n\t  'mediumaquamarine': [102, 205, 170, 1],\n\t  'mediumblue': [0, 0, 205, 1],\n\t  'mediumorchid': [186, 85, 211, 1],\n\t  'mediumpurple': [147, 112, 219, 1],\n\t  'mediumseagreen': [60, 179, 113, 1],\n\t  'mediumslateblue': [123, 104, 238, 1],\n\t  'mediumspringgreen': [0, 250, 154, 1],\n\t  'mediumturquoise': [72, 209, 204, 1],\n\t  'mediumvioletred': [199, 21, 133, 1],\n\t  'midnightblue': [25, 25, 112, 1],\n\t  'mintcream': [245, 255, 250, 1],\n\t  'mistyrose': [255, 228, 225, 1],\n\t  'moccasin': [255, 228, 181, 1],\n\t  'navajowhite': [255, 222, 173, 1],\n\t  'navy': [0, 0, 128, 1],\n\t  'oldlace': [253, 245, 230, 1],\n\t  'olive': [128, 128, 0, 1],\n\t  'olivedrab': [107, 142, 35, 1],\n\t  'orange': [255, 165, 0, 1],\n\t  'orangered': [255, 69, 0, 1],\n\t  'orchid': [218, 112, 214, 1],\n\t  'palegoldenrod': [238, 232, 170, 1],\n\t  'palegreen': [152, 251, 152, 1],\n\t  'paleturquoise': [175, 238, 238, 1],\n\t  'palevioletred': [219, 112, 147, 1],\n\t  'papayawhip': [255, 239, 213, 1],\n\t  'peachpuff': [255, 218, 185, 1],\n\t  'peru': [205, 133, 63, 1],\n\t  'pink': [255, 192, 203, 1],\n\t  'plum': [221, 160, 221, 1],\n\t  'powderblue': [176, 224, 230, 1],\n\t  'purple': [128, 0, 128, 1],\n\t  'red': [255, 0, 0, 1],\n\t  'rosybrown': [188, 143, 143, 1],\n\t  'royalblue': [65, 105, 225, 1],\n\t  'saddlebrown': [139, 69, 19, 1],\n\t  'salmon': [250, 128, 114, 1],\n\t  'sandybrown': [244, 164, 96, 1],\n\t  'seagreen': [46, 139, 87, 1],\n\t  'seashell': [255, 245, 238, 1],\n\t  'sienna': [160, 82, 45, 1],\n\t  'silver': [192, 192, 192, 1],\n\t  'skyblue': [135, 206, 235, 1],\n\t  'slateblue': [106, 90, 205, 1],\n\t  'slategray': [112, 128, 144, 1],\n\t  'slategrey': [112, 128, 144, 1],\n\t  'snow': [255, 250, 250, 1],\n\t  'springgreen': [0, 255, 127, 1],\n\t  'steelblue': [70, 130, 180, 1],\n\t  'tan': [210, 180, 140, 1],\n\t  'teal': [0, 128, 128, 1],\n\t  'thistle': [216, 191, 216, 1],\n\t  'tomato': [255, 99, 71, 1],\n\t  'turquoise': [64, 224, 208, 1],\n\t  'violet': [238, 130, 238, 1],\n\t  'wheat': [245, 222, 179, 1],\n\t  'white': [255, 255, 255, 1],\n\t  'whitesmoke': [245, 245, 245, 1],\n\t  'yellow': [255, 255, 0, 1],\n\t  'yellowgreen': [154, 205, 50, 1]\n\t};\n\t\n\tfunction clampCssByte(i) {\n\t  // Clamp to integer 0 .. 255.\n\t  i = Math.round(i); // Seems to be what Chrome does (vs truncation).\n\t\n\t  return i < 0 ? 0 : i > 255 ? 255 : i;\n\t}\n\t\n\tfunction clampCssAngle(i) {\n\t  // Clamp to integer 0 .. 360.\n\t  i = Math.round(i); // Seems to be what Chrome does (vs truncation).\n\t\n\t  return i < 0 ? 0 : i > 360 ? 360 : i;\n\t}\n\t\n\tfunction clampCssFloat(f) {\n\t  // Clamp to float 0.0 .. 1.0.\n\t  return f < 0 ? 0 : f > 1 ? 1 : f;\n\t}\n\t\n\tfunction parseCssInt(str) {\n\t  // int or percentage.\n\t  if (str.length && str.charAt(str.length - 1) === '%') {\n\t    return clampCssByte(parseFloat(str) / 100 * 255);\n\t  }\n\t\n\t  return clampCssByte(parseInt(str, 10));\n\t}\n\t\n\tfunction parseCssFloat(str) {\n\t  // float or percentage.\n\t  if (str.length && str.charAt(str.length - 1) === '%') {\n\t    return clampCssFloat(parseFloat(str) / 100);\n\t  }\n\t\n\t  return clampCssFloat(parseFloat(str));\n\t}\n\t\n\tfunction cssHueToRgb(m1, m2, h) {\n\t  if (h < 0) {\n\t    h += 1;\n\t  } else if (h > 1) {\n\t    h -= 1;\n\t  }\n\t\n\t  if (h * 6 < 1) {\n\t    return m1 + (m2 - m1) * h * 6;\n\t  }\n\t\n\t  if (h * 2 < 1) {\n\t    return m2;\n\t  }\n\t\n\t  if (h * 3 < 2) {\n\t    return m1 + (m2 - m1) * (2 / 3 - h) * 6;\n\t  }\n\t\n\t  return m1;\n\t}\n\t\n\tfunction lerpNumber(a, b, p) {\n\t  return a + (b - a) * p;\n\t}\n\t\n\tfunction setRgba(out, r, g, b, a) {\n\t  out[0] = r;\n\t  out[1] = g;\n\t  out[2] = b;\n\t  out[3] = a;\n\t  return out;\n\t}\n\t\n\tfunction copyRgba(out, a) {\n\t  out[0] = a[0];\n\t  out[1] = a[1];\n\t  out[2] = a[2];\n\t  out[3] = a[3];\n\t  return out;\n\t}\n\t\n\tvar colorCache = new LRU(20);\n\tvar lastRemovedArr = null;\n\t\n\tfunction putToCache(colorStr, rgbaArr) {\n\t  // Reuse removed array\n\t  if (lastRemovedArr) {\n\t    copyRgba(lastRemovedArr, rgbaArr);\n\t  }\n\t\n\t  lastRemovedArr = colorCache.put(colorStr, lastRemovedArr || rgbaArr.slice());\n\t}\n\t/**\n\t * @param {string} colorStr\n\t * @param {Array.<number>} out\n\t * @return {Array.<number>}\n\t * @memberOf module:zrender/util/color\n\t */\n\t\n\t\n\tfunction parse(colorStr, rgbaArr) {\n\t  if (!colorStr) {\n\t    return;\n\t  }\n\t\n\t  rgbaArr = rgbaArr || [];\n\t  var cached = colorCache.get(colorStr);\n\t\n\t  if (cached) {\n\t    return copyRgba(rgbaArr, cached);\n\t  } // colorStr may be not string\n\t\n\t\n\t  colorStr = colorStr + ''; // Remove all whitespace, not compliant, but should just be more accepting.\n\t\n\t  var str = colorStr.replace(/ /g, '').toLowerCase(); // Color keywords (and transparent) lookup.\n\t\n\t  if (str in kCSSColorTable) {\n\t    copyRgba(rgbaArr, kCSSColorTable[str]);\n\t    putToCache(colorStr, rgbaArr);\n\t    return rgbaArr;\n\t  } // #abc and #abc123 syntax.\n\t\n\t\n\t  if (str.charAt(0) === '#') {\n\t    if (str.length === 4) {\n\t      var iv = parseInt(str.substr(1), 16); // TODO(deanm): Stricter parsing.\n\t\n\t      if (!(iv >= 0 && iv <= 0xfff)) {\n\t        setRgba(rgbaArr, 0, 0, 0, 1);\n\t        return; // Covers NaN.\n\t      }\n\t\n\t      setRgba(rgbaArr, (iv & 0xf00) >> 4 | (iv & 0xf00) >> 8, iv & 0xf0 | (iv & 0xf0) >> 4, iv & 0xf | (iv & 0xf) << 4, 1);\n\t      putToCache(colorStr, rgbaArr);\n\t      return rgbaArr;\n\t    } else if (str.length === 7) {\n\t      var iv = parseInt(str.substr(1), 16); // TODO(deanm): Stricter parsing.\n\t\n\t      if (!(iv >= 0 && iv <= 0xffffff)) {\n\t        setRgba(rgbaArr, 0, 0, 0, 1);\n\t        return; // Covers NaN.\n\t      }\n\t\n\t      setRgba(rgbaArr, (iv & 0xff0000) >> 16, (iv & 0xff00) >> 8, iv & 0xff, 1);\n\t      putToCache(colorStr, rgbaArr);\n\t      return rgbaArr;\n\t    }\n\t\n\t    return;\n\t  }\n\t\n\t  var op = str.indexOf('('),\n\t      ep = str.indexOf(')');\n\t\n\t  if (op !== -1 && ep + 1 === str.length) {\n\t    var fname = str.substr(0, op);\n\t    var params = str.substr(op + 1, ep - (op + 1)).split(',');\n\t    var alpha = 1; // To allow case fallthrough.\n\t\n\t    switch (fname) {\n\t      case 'rgba':\n\t        if (params.length !== 4) {\n\t          setRgba(rgbaArr, 0, 0, 0, 1);\n\t          return;\n\t        }\n\t\n\t        alpha = parseCssFloat(params.pop());\n\t      // jshint ignore:line\n\t      // Fall through.\n\t\n\t      case 'rgb':\n\t        if (params.length !== 3) {\n\t          setRgba(rgbaArr, 0, 0, 0, 1);\n\t          return;\n\t        }\n\t\n\t        setRgba(rgbaArr, parseCssInt(params[0]), parseCssInt(params[1]), parseCssInt(params[2]), alpha);\n\t        putToCache(colorStr, rgbaArr);\n\t        return rgbaArr;\n\t\n\t      case 'hsla':\n\t        if (params.length !== 4) {\n\t          setRgba(rgbaArr, 0, 0, 0, 1);\n\t          return;\n\t        }\n\t\n\t        params[3] = parseCssFloat(params[3]);\n\t        hsla2rgba(params, rgbaArr);\n\t        putToCache(colorStr, rgbaArr);\n\t        return rgbaArr;\n\t\n\t      case 'hsl':\n\t        if (params.length !== 3) {\n\t          setRgba(rgbaArr, 0, 0, 0, 1);\n\t          return;\n\t        }\n\t\n\t        hsla2rgba(params, rgbaArr);\n\t        putToCache(colorStr, rgbaArr);\n\t        return rgbaArr;\n\t\n\t      default:\n\t        return;\n\t    }\n\t  }\n\t\n\t  setRgba(rgbaArr, 0, 0, 0, 1);\n\t  return;\n\t}\n\t/**\n\t * @param {Array.<number>} hsla\n\t * @param {Array.<number>} rgba\n\t * @return {Array.<number>} rgba\n\t */\n\t\n\t\n\tfunction hsla2rgba(hsla, rgba) {\n\t  var h = (parseFloat(hsla[0]) % 360 + 360) % 360 / 360; // 0 .. 1\n\t  // NOTE(deanm): According to the CSS spec s/l should only be\n\t  // percentages, but we don't bother and let float or percentage.\n\t\n\t  var s = parseCssFloat(hsla[1]);\n\t  var l = parseCssFloat(hsla[2]);\n\t  var m2 = l <= 0.5 ? l * (s + 1) : l + s - l * s;\n\t  var m1 = l * 2 - m2;\n\t  rgba = rgba || [];\n\t  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\t\n\t  if (hsla.length === 4) {\n\t    rgba[3] = hsla[3];\n\t  }\n\t\n\t  return rgba;\n\t}\n\t/**\n\t * @param {Array.<number>} rgba\n\t * @return {Array.<number>} hsla\n\t */\n\t\n\t\n\tfunction rgba2hsla(rgba) {\n\t  if (!rgba) {\n\t    return;\n\t  } // RGB from 0 to 255\n\t\n\t\n\t  var R = rgba[0] / 255;\n\t  var G = rgba[1] / 255;\n\t  var B = rgba[2] / 255;\n\t  var vMin = Math.min(R, G, B); // Min. value of RGB\n\t\n\t  var vMax = Math.max(R, G, B); // Max. value of RGB\n\t\n\t  var delta = vMax - vMin; // Delta RGB value\n\t\n\t  var L = (vMax + vMin) / 2;\n\t  var H;\n\t  var S; // HSL results from 0 to 1\n\t\n\t  if (delta === 0) {\n\t    H = 0;\n\t    S = 0;\n\t  } else {\n\t    if (L < 0.5) {\n\t      S = delta / (vMax + vMin);\n\t    } else {\n\t      S = delta / (2 - vMax - vMin);\n\t    }\n\t\n\t    var deltaR = ((vMax - R) / 6 + delta / 2) / delta;\n\t    var deltaG = ((vMax - G) / 6 + delta / 2) / delta;\n\t    var deltaB = ((vMax - B) / 6 + delta / 2) / delta;\n\t\n\t    if (R === vMax) {\n\t      H = deltaB - deltaG;\n\t    } else if (G === vMax) {\n\t      H = 1 / 3 + deltaR - deltaB;\n\t    } else if (B === vMax) {\n\t      H = 2 / 3 + deltaG - deltaR;\n\t    }\n\t\n\t    if (H < 0) {\n\t      H += 1;\n\t    }\n\t\n\t    if (H > 1) {\n\t      H -= 1;\n\t    }\n\t  }\n\t\n\t  var hsla = [H * 360, S, L];\n\t\n\t  if (rgba[3] != null) {\n\t    hsla.push(rgba[3]);\n\t  }\n\t\n\t  return hsla;\n\t}\n\t/**\n\t * @param {string} color\n\t * @param {number} level\n\t * @return {string}\n\t * @memberOf module:zrender/util/color\n\t */\n\t\n\t\n\tfunction lift(color, level) {\n\t  var colorArr = parse(color);\n\t\n\t  if (colorArr) {\n\t    for (var i = 0; i < 3; i++) {\n\t      if (level < 0) {\n\t        colorArr[i] = colorArr[i] * (1 - level) | 0;\n\t      } else {\n\t        colorArr[i] = (255 - colorArr[i]) * level + colorArr[i] | 0;\n\t      }\n\t    }\n\t\n\t    return stringify(colorArr, colorArr.length === 4 ? 'rgba' : 'rgb');\n\t  }\n\t}\n\t/**\n\t * @param {string} color\n\t * @return {string}\n\t * @memberOf module:zrender/util/color\n\t */\n\t\n\t\n\tfunction toHex(color) {\n\t  var colorArr = parse(color);\n\t\n\t  if (colorArr) {\n\t    return ((1 << 24) + (colorArr[0] << 16) + (colorArr[1] << 8) + +colorArr[2]).toString(16).slice(1);\n\t  }\n\t}\n\t/**\n\t * Map value to color. Faster than lerp methods because color is represented by rgba array.\n\t * @param {number} normalizedValue A float between 0 and 1.\n\t * @param {Array.<Array.<number>>} colors List of rgba color array\n\t * @param {Array.<number>} [out] Mapped gba color array\n\t * @return {Array.<number>} will be null/undefined if input illegal.\n\t */\n\t\n\t\n\tfunction fastLerp(normalizedValue, colors, out) {\n\t  if (!(colors && colors.length) || !(normalizedValue >= 0 && normalizedValue <= 1)) {\n\t    return;\n\t  }\n\t\n\t  out = out || [];\n\t  var value = normalizedValue * (colors.length - 1);\n\t  var leftIndex = Math.floor(value);\n\t  var rightIndex = Math.ceil(value);\n\t  var leftColor = colors[leftIndex];\n\t  var rightColor = colors[rightIndex];\n\t  var dv = value - leftIndex;\n\t  out[0] = clampCssByte(lerpNumber(leftColor[0], rightColor[0], dv));\n\t  out[1] = clampCssByte(lerpNumber(leftColor[1], rightColor[1], dv));\n\t  out[2] = clampCssByte(lerpNumber(leftColor[2], rightColor[2], dv));\n\t  out[3] = clampCssFloat(lerpNumber(leftColor[3], rightColor[3], dv));\n\t  return out;\n\t}\n\t/**\n\t * @deprecated\n\t */\n\t\n\t\n\tvar fastMapToColor = fastLerp;\n\t/**\n\t * @param {number} normalizedValue A float between 0 and 1.\n\t * @param {Array.<string>} colors Color list.\n\t * @param {boolean=} fullOutput Default false.\n\t * @return {(string|Object)} Result color. If fullOutput,\n\t *                           return {color: ..., leftIndex: ..., rightIndex: ..., value: ...},\n\t * @memberOf module:zrender/util/color\n\t */\n\t\n\tfunction lerp(normalizedValue, colors, fullOutput) {\n\t  if (!(colors && colors.length) || !(normalizedValue >= 0 && normalizedValue <= 1)) {\n\t    return;\n\t  }\n\t\n\t  var value = normalizedValue * (colors.length - 1);\n\t  var leftIndex = Math.floor(value);\n\t  var rightIndex = Math.ceil(value);\n\t  var leftColor = parse(colors[leftIndex]);\n\t  var rightColor = parse(colors[rightIndex]);\n\t  var dv = value - leftIndex;\n\t  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\t  return fullOutput ? {\n\t    color: color,\n\t    leftIndex: leftIndex,\n\t    rightIndex: rightIndex,\n\t    value: value\n\t  } : color;\n\t}\n\t/**\n\t * @deprecated\n\t */\n\t\n\t\n\tvar mapToColor = lerp;\n\t/**\n\t * @param {string} color\n\t * @param {number=} h 0 ~ 360, ignore when null.\n\t * @param {number=} s 0 ~ 1, ignore when null.\n\t * @param {number=} l 0 ~ 1, ignore when null.\n\t * @return {string} Color string in rgba format.\n\t * @memberOf module:zrender/util/color\n\t */\n\t\n\tfunction modifyHSL(color, h, s, l) {\n\t  color = parse(color);\n\t\n\t  if (color) {\n\t    color = rgba2hsla(color);\n\t    h != null && (color[0] = clampCssAngle(h));\n\t    s != null && (color[1] = parseCssFloat(s));\n\t    l != null && (color[2] = parseCssFloat(l));\n\t    return stringify(hsla2rgba(color), 'rgba');\n\t  }\n\t}\n\t/**\n\t * @param {string} color\n\t * @param {number=} alpha 0 ~ 1\n\t * @return {string} Color string in rgba format.\n\t * @memberOf module:zrender/util/color\n\t */\n\t\n\t\n\tfunction modifyAlpha(color, alpha) {\n\t  color = parse(color);\n\t\n\t  if (color && alpha != null) {\n\t    color[3] = clampCssFloat(alpha);\n\t    return stringify(color, 'rgba');\n\t  }\n\t}\n\t/**\n\t * @param {Array.<number>} arrColor like [12,33,44,0.4]\n\t * @param {string} type 'rgba', 'hsva', ...\n\t * @return {string} Result color. (If input illegal, return undefined).\n\t */\n\t\n\t\n\tfunction stringify(arrColor, type) {\n\t  if (!arrColor || !arrColor.length) {\n\t    return;\n\t  }\n\t\n\t  var colorStr = arrColor[0] + ',' + arrColor[1] + ',' + arrColor[2];\n\t\n\t  if (type === 'rgba' || type === 'hsva' || type === 'hsla') {\n\t    colorStr += ',' + arrColor[3];\n\t  }\n\t\n\t  return type + '(' + colorStr + ')';\n\t}\n\t\n\texports.parse = parse;\n\texports.lift = lift;\n\texports.toHex = toHex;\n\texports.fastLerp = fastLerp;\n\texports.fastMapToColor = fastMapToColor;\n\texports.lerp = lerp;\n\texports.mapToColor = mapToColor;\n\texports.modifyHSL = modifyHSL;\n\texports.modifyAlpha = modifyAlpha;\n\texports.stringify = stringify;\n\n/***/ },\n/* 27 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar _util = __webpack_require__(1);\n\t\n\tvar createHashMap = _util.createHashMap;\n\tvar each = _util.each;\n\tvar isString = _util.isString;\n\tvar defaults = _util.defaults;\n\tvar extend = _util.extend;\n\tvar isObject = _util.isObject;\n\tvar clone = _util.clone;\n\t\n\tvar _model = __webpack_require__(14);\n\t\n\tvar normalizeToArray = _model.normalizeToArray;\n\t\n\tvar _sourceHelper = __webpack_require__(29);\n\t\n\tvar guessOrdinal = _sourceHelper.guessOrdinal;\n\t\n\tvar Source = __webpack_require__(12);\n\t\n\tvar _dimensionHelper = __webpack_require__(28);\n\t\n\tvar OTHER_DIMENSIONS = _dimensionHelper.OTHER_DIMENSIONS;\n\t\n\t/**\n\t * @deprecated\n\t * Use `echarts/data/helper/createDimensions` instead.\n\t */\n\t\n\t/**\n\t * @see {module:echarts/test/ut/spec/data/completeDimensions}\n\t *\n\t * Complete the dimensions array, by user defined `dimension` and `encode`,\n\t * and guessing from the data structure.\n\t * If no 'value' dimension specified, the first no-named dimension will be\n\t * named as 'value'.\n\t *\n\t * @param {Array.<string>} sysDims Necessary dimensions, like ['x', 'y'], which\n\t *      provides not only dim template, but also default order.\n\t *      properties: 'name', 'type', 'displayName'.\n\t *      `name` of each item provides default coord name.\n\t *      [{dimsDef: [string...]}, ...] can be specified to give names.\n\t *      [{ordinalMeta}] can be specified.\n\t * @param {module:echarts/data/Source|Array|Object} source or data (for compatibal with pervious)\n\t * @param {Object} [opt]\n\t * @param {Array.<Object|string>} [opt.dimsDef] option.series.dimensions User defined dimensions\n\t *      For example: ['asdf', {name, type}, ...].\n\t * @param {Object|HashMap} [opt.encodeDef] option.series.encode {x: 2, y: [3, 1], tooltip: [1, 2], label: 3}\n\t * @param {string} [opt.extraPrefix] Prefix of name when filling the left dimensions.\n\t * @param {string} [opt.extraFromZero] If specified, extra dim names will be:\n\t *                      extraPrefix + 0, extraPrefix + extraBaseIndex + 1 ...\n\t *                      If not specified, extra dim names will be:\n\t *                      extraPrefix, extraPrefix + 0, extraPrefix + 1 ...\n\t * @param {number} [opt.dimCount] If not specified, guess by the first data item.\n\t * @param {number} [opt.encodeDefaulter] If not specified, auto find the next available data dim.\n\t * @return {Array.<Object>} [{\n\t *      name: string mandatory,\n\t *      displayName: string, the origin name in dimsDef, see source helper.\n\t *                 If displayName given, the tooltip will displayed vertically.\n\t *      coordDim: string mandatory,\n\t *      isSysCoord: boolean True if the coord is from sys dimension.\n\t *      coordDimIndex: number mandatory,\n\t *      type: string optional,\n\t *      otherDims: { never null/undefined\n\t *          tooltip: number optional,\n\t *          label: number optional,\n\t *          itemName: number optional,\n\t *          seriesName: number optional,\n\t *      },\n\t *      isExtraCoord: boolean true or undefined.\n\t *      other props ...\n\t * }]\n\t */\n\tfunction completeDimensions(sysDims, source, opt) {\n\t  if (!Source.isInstance(source)) {\n\t    source = Source.seriesDataToSource(source);\n\t  }\n\t\n\t  opt = opt || {};\n\t  sysDims = (sysDims || []).slice();\n\t  var dimsDef = (opt.dimsDef || []).slice();\n\t  var encodeDef = createHashMap(opt.encodeDef);\n\t  var dataDimNameMap = createHashMap();\n\t  var coordDimNameMap = createHashMap(); // var valueCandidate;\n\t\n\t  var result = [];\n\t  var dimCount = getDimCount(source, sysDims, dimsDef, opt.dimCount); // Apply user defined dims (`name` and `type`) and init result.\n\t\n\t  for (var i = 0; i < dimCount; i++) {\n\t    var dimDefItem = dimsDef[i] = extend({}, isObject(dimsDef[i]) ? dimsDef[i] : {\n\t      name: dimsDef[i]\n\t    });\n\t    var userDimName = dimDefItem.name;\n\t    var resultItem = result[i] = {\n\t      otherDims: {}\n\t    }; // Name will be applied later for avoiding duplication.\n\t\n\t    if (userDimName != null && dataDimNameMap.get(userDimName) == null) {\n\t      // Only if `series.dimensions` is defined in option\n\t      // displayName, will be set, and dimension will be diplayed vertically in\n\t      // tooltip by default.\n\t      resultItem.name = resultItem.displayName = userDimName;\n\t      dataDimNameMap.set(userDimName, i);\n\t    }\n\t\n\t    dimDefItem.type != null && (resultItem.type = dimDefItem.type);\n\t    dimDefItem.displayName != null && (resultItem.displayName = dimDefItem.displayName);\n\t  } // Set `coordDim` and `coordDimIndex` by `encodeDef` and normalize `encodeDef`.\n\t\n\t\n\t  encodeDef.each(function (dataDims, coordDim) {\n\t    dataDims = normalizeToArray(dataDims).slice();\n\t    var validDataDims = encodeDef.set(coordDim, []);\n\t    each(dataDims, function (resultDimIdx, idx) {\n\t      // The input resultDimIdx can be dim name or index.\n\t      isString(resultDimIdx) && (resultDimIdx = dataDimNameMap.get(resultDimIdx));\n\t\n\t      if (resultDimIdx != null && resultDimIdx < dimCount) {\n\t        validDataDims[idx] = resultDimIdx;\n\t        applyDim(result[resultDimIdx], coordDim, idx);\n\t      }\n\t    });\n\t  }); // Apply templetes and default order from `sysDims`.\n\t\n\t  var availDimIdx = 0;\n\t  each(sysDims, function (sysDimItem, sysDimIndex) {\n\t    var coordDim;\n\t    var sysDimItem;\n\t    var sysDimItemDimsDef;\n\t    var sysDimItemOtherDims;\n\t\n\t    if (isString(sysDimItem)) {\n\t      coordDim = sysDimItem;\n\t      sysDimItem = {};\n\t    } else {\n\t      coordDim = sysDimItem.name;\n\t      var ordinalMeta = sysDimItem.ordinalMeta;\n\t      sysDimItem.ordinalMeta = null;\n\t      sysDimItem = clone(sysDimItem);\n\t      sysDimItem.ordinalMeta = ordinalMeta; // `coordDimIndex` should not be set directly.\n\t\n\t      sysDimItemDimsDef = sysDimItem.dimsDef;\n\t      sysDimItemOtherDims = sysDimItem.otherDims;\n\t      sysDimItem.name = sysDimItem.coordDim = sysDimItem.coordDimIndex = sysDimItem.dimsDef = sysDimItem.otherDims = null;\n\t    }\n\t\n\t    var dataDims = normalizeToArray(encodeDef.get(coordDim)); // dimensions provides default dim sequences.\n\t\n\t    if (!dataDims.length) {\n\t      for (var i = 0; i < (sysDimItemDimsDef && sysDimItemDimsDef.length || 1); i++) {\n\t        while (availDimIdx < result.length && result[availDimIdx].coordDim != null) {\n\t          availDimIdx++;\n\t        }\n\t\n\t        availDimIdx < result.length && dataDims.push(availDimIdx++);\n\t      }\n\t    } // Apply templates.\n\t\n\t\n\t    each(dataDims, function (resultDimIdx, coordDimIndex) {\n\t      var resultItem = result[resultDimIdx];\n\t      applyDim(defaults(resultItem, sysDimItem), coordDim, coordDimIndex);\n\t\n\t      if (resultItem.name == null && sysDimItemDimsDef) {\n\t        resultItem.name = resultItem.displayName = sysDimItemDimsDef[coordDimIndex];\n\t      }\n\t\n\t      resultItem.isSysCoord = true; // FIXME refactor, currently only used in case: {otherDims: {tooltip: false}}\n\t\n\t      sysDimItemOtherDims && defaults(resultItem.otherDims, sysDimItemOtherDims);\n\t    });\n\t  });\n\t\n\t  function applyDim(resultItem, coordDim, coordDimIndex) {\n\t    if (OTHER_DIMENSIONS.get(coordDim) != null) {\n\t      resultItem.otherDims[coordDim] = coordDimIndex;\n\t    } else {\n\t      resultItem.coordDim = coordDim;\n\t      resultItem.coordDimIndex = coordDimIndex;\n\t      coordDimNameMap.set(coordDim, true);\n\t    }\n\t  } // Make sure the first extra dim is 'value'.\n\t\n\t\n\t  var extra = opt.extraPrefix || 'value'; // Set dim `name` and other `coordDim` and other props.\n\t\n\t  for (var resultDimIdx = 0; resultDimIdx < dimCount; resultDimIdx++) {\n\t    var resultItem = result[resultDimIdx] = result[resultDimIdx] || {};\n\t    var coordDim = resultItem.coordDim;\n\t    coordDim == null && (resultItem.coordDim = genName(extra, coordDimNameMap, opt.extraFromZero), resultItem.coordDimIndex = 0, resultItem.isExtraCoord = true);\n\t    resultItem.name == null && (resultItem.name = genName(resultItem.coordDim, dataDimNameMap));\n\t\n\t    if (resultItem.type == null && guessOrdinal(source, resultDimIdx, resultItem.name)) {\n\t      resultItem.type = 'ordinal';\n\t    }\n\t  }\n\t\n\t  return result;\n\t} // ??? TODO\n\t// Originally detect dimCount by data[0]. Should we\n\t// optimize it to only by sysDims and dimensions and encode.\n\t// So only necessary dims will be initialized.\n\t// But\n\t// (1) custom series should be considered. where other dims\n\t// may be visited.\n\t// (2) sometimes user need to calcualte bubble size or use visualMap\n\t// on other dimensions besides coordSys needed.\n\t\n\t\n\tfunction getDimCount(source, sysDims, dimsDef, dimCount) {\n\t  if (dimCount == null) {\n\t    dimCount = Math.max(source.dimensionsDetectCount || 1, sysDims.length, dimsDef.length);\n\t    each(sysDims, function (sysDimItem) {\n\t      var sysDimItemDimsDef = sysDimItem.dimsDef;\n\t      sysDimItemDimsDef && (dimCount = Math.max(dimCount, sysDimItemDimsDef.length));\n\t    });\n\t  }\n\t\n\t  return dimCount;\n\t}\n\t\n\tfunction genName(name, map, fromZero) {\n\t  if (fromZero || map.get(name) != null) {\n\t    var i = 0;\n\t\n\t    while (map.get(name + i) != null) {\n\t      i++;\n\t    }\n\t\n\t    name += i;\n\t  }\n\t\n\t  map.set(name, true);\n\t  return name;\n\t}\n\t\n\tvar _default = completeDimensions;\n\tmodule.exports = _default;\n\n/***/ },\n/* 28 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar _util = __webpack_require__(1);\n\t\n\tvar each = _util.each;\n\tvar createHashMap = _util.createHashMap;\n\tvar assert = _util.assert;\n\t\n\tvar _config = __webpack_require__(6);\n\t\n\tvar __DEV__ = _config.__DEV__;\n\tvar OTHER_DIMENSIONS = createHashMap(['tooltip', 'label', 'itemName', 'itemId', 'seriesName']);\n\t\n\tfunction summarizeDimensions(data) {\n\t  var summary = {};\n\t  var encode = summary.encode = {};\n\t  var coordDimMap = summary.coordDimMap = createHashMap();\n\t  var defaultedLabel = [];\n\t  each(data.dimensions, function (dimName) {\n\t    var dimItem = data.getDimensionInfo(dimName);\n\t    var coordDim = dimItem.coordDim;\n\t\n\t    if (coordDim) {\n\t      var coordDimArr = encode[coordDim];\n\t\n\t      if (!encode.hasOwnProperty(coordDim)) {\n\t        coordDimArr = encode[coordDim] = [];\n\t      }\n\t\n\t      coordDimArr[dimItem.coordDimIndex] = dimName;\n\t\n\t      if (dimItem.isSysCoord && mayLabelDimType(dimItem.type)) {\n\t        // Use the last coord dim (and label friendly) as default label,\n\t        // because both show x, y on label is not look good, and usually\n\t        // y axis is more focusd conventionally.\n\t        defaultedLabel[0] = dimName;\n\t      }\n\t\n\t      coordDimMap.set(coordDim, 1);\n\t    }\n\t\n\t    OTHER_DIMENSIONS.each(function (v, otherDim) {\n\t      var otherDimArr = encode[otherDim];\n\t\n\t      if (!encode.hasOwnProperty(otherDim)) {\n\t        otherDimArr = encode[otherDim] = [];\n\t      }\n\t\n\t      var dimIndex = dimItem.otherDims[otherDim];\n\t\n\t      if (dimIndex != null && dimIndex !== false) {\n\t        otherDimArr[dimIndex] = dimItem.name;\n\t      }\n\t    });\n\t  });\n\t  var dataDimsOnCoord = [];\n\t  coordDimMap.each(function (v, coordDim) {\n\t    dataDimsOnCoord = dataDimsOnCoord.concat(encode[coordDim]);\n\t  });\n\t  summary.dataDimsOnCoord = dataDimsOnCoord;\n\t  var encodeLabel = encode.label; // FIXME `encode.label` is not recommanded, because formatter can not be set\n\t  // in this way. Use label.formatter instead. May be remove this approach someday.\n\t\n\t  if (encodeLabel && encodeLabel.length) {\n\t    defaultedLabel = encodeLabel.slice();\n\t  }\n\t\n\t  var defaultedTooltip = defaultedLabel.slice();\n\t  var encodeTooltip = encode.tooltip;\n\t\n\t  if (encodeTooltip && encodeTooltip.length) {\n\t    defaultedTooltip = encodeTooltip.slice();\n\t  }\n\t\n\t  encode.defaultedLabel = defaultedLabel;\n\t  encode.defaultedTooltip = defaultedTooltip;\n\t  return summary;\n\t}\n\t\n\tfunction getDimensionTypeByAxis(axisType) {\n\t  return axisType === 'category' ? 'ordinal' : axisType === 'time' ? 'time' : 'float';\n\t}\n\t\n\tfunction mayLabelDimType(dimType) {\n\t  // In most cases, ordinal and time do not suitable for label.\n\t  // Ordinal info can be displayed on axis. Time is too long.\n\t  return !(dimType === 'ordinal' || dimType === 'time');\n\t} // function findTheLastDimMayLabel(data) {\n\t//     // Get last value dim\n\t//     var dimensions = data.dimensions.slice();\n\t//     var valueType;\n\t//     var valueDim;\n\t//     while (dimensions.length && (\n\t//         valueDim = dimensions.pop(),\n\t//         valueType = data.getDimensionInfo(valueDim).type,\n\t//         valueType === 'ordinal' || valueType === 'time'\n\t//     )) {} // jshint ignore:line\n\t//     return valueDim;\n\t// }\n\t\n\t\n\texports.OTHER_DIMENSIONS = OTHER_DIMENSIONS;\n\texports.summarizeDimensions = summarizeDimensions;\n\texports.getDimensionTypeByAxis = getDimensionTypeByAxis;\n\n/***/ },\n/* 29 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar _config = __webpack_require__(6);\n\t\n\tvar __DEV__ = _config.__DEV__;\n\t\n\tvar _model = __webpack_require__(14);\n\t\n\tvar makeInner = _model.makeInner;\n\tvar getDataItemValue = _model.getDataItemValue;\n\t\n\tvar _referHelper = __webpack_require__(30);\n\t\n\tvar getCoordSysDefineBySeries = _referHelper.getCoordSysDefineBySeries;\n\t\n\tvar _util = __webpack_require__(1);\n\t\n\tvar createHashMap = _util.createHashMap;\n\tvar each = _util.each;\n\tvar map = _util.map;\n\tvar isArray = _util.isArray;\n\tvar isString = _util.isString;\n\tvar isObject = _util.isObject;\n\tvar isTypedArray = _util.isTypedArray;\n\tvar isArrayLike = _util.isArrayLike;\n\tvar extend = _util.extend;\n\tvar assert = _util.assert;\n\t\n\tvar Source = __webpack_require__(12);\n\t\n\tvar _sourceType = __webpack_require__(13);\n\t\n\tvar SOURCE_FORMAT_ORIGINAL = _sourceType.SOURCE_FORMAT_ORIGINAL;\n\tvar SOURCE_FORMAT_ARRAY_ROWS = _sourceType.SOURCE_FORMAT_ARRAY_ROWS;\n\tvar SOURCE_FORMAT_OBJECT_ROWS = _sourceType.SOURCE_FORMAT_OBJECT_ROWS;\n\tvar SOURCE_FORMAT_KEYED_COLUMNS = _sourceType.SOURCE_FORMAT_KEYED_COLUMNS;\n\tvar SOURCE_FORMAT_UNKNOWN = _sourceType.SOURCE_FORMAT_UNKNOWN;\n\tvar SOURCE_FORMAT_TYPED_ARRAY = _sourceType.SOURCE_FORMAT_TYPED_ARRAY;\n\tvar SERIES_LAYOUT_BY_ROW = _sourceType.SERIES_LAYOUT_BY_ROW;\n\tvar inner = makeInner();\n\t/**\n\t * @see {module:echarts/data/Source}\n\t * @param {module:echarts/component/dataset/DatasetModel} datasetModel\n\t * @return {string} sourceFormat\n\t */\n\t\n\tfunction detectSourceFormat(datasetModel) {\n\t  var data = datasetModel.option.source;\n\t  var sourceFormat = SOURCE_FORMAT_UNKNOWN;\n\t\n\t  if (isTypedArray(data)) {\n\t    sourceFormat = SOURCE_FORMAT_TYPED_ARRAY;\n\t  } else if (isArray(data)) {\n\t    // FIXME Whether tolerate null in top level array?\n\t    for (var i = 0, len = data.length; i < len; i++) {\n\t      var item = data[i];\n\t\n\t      if (item == null) {\n\t        continue;\n\t      } else if (isArray(item)) {\n\t        sourceFormat = SOURCE_FORMAT_ARRAY_ROWS;\n\t        break;\n\t      } else if (isObject(item)) {\n\t        sourceFormat = SOURCE_FORMAT_OBJECT_ROWS;\n\t        break;\n\t      }\n\t    }\n\t  } else if (isObject(data)) {\n\t    for (var key in data) {\n\t      if (data.hasOwnProperty(key) && isArrayLike(data[key])) {\n\t        sourceFormat = SOURCE_FORMAT_KEYED_COLUMNS;\n\t        break;\n\t      }\n\t    }\n\t  } else if (data != null) {\n\t    throw new Error('Invalid data');\n\t  }\n\t\n\t  inner(datasetModel).sourceFormat = sourceFormat;\n\t}\n\t/**\n\t * [Scenarios]:\n\t * (1) Provide source data directly:\n\t *     series: {\n\t *         encode: {...},\n\t *         dimensions: [...]\n\t *         seriesLayoutBy: 'row',\n\t *         data: [[...]]\n\t *     }\n\t * (2) Refer to datasetModel.\n\t *     series: [{\n\t *         encode: {...}\n\t *         // Ignore datasetIndex means `datasetIndex: 0`\n\t *         // and the dimensions defination in dataset is used\n\t *     }, {\n\t *         encode: {...},\n\t *         seriesLayoutBy: 'column',\n\t *         datasetIndex: 1\n\t *     }]\n\t *\n\t * Get data from series itself or datset.\n\t * @return {module:echarts/data/Source} source\n\t */\n\t\n\t\n\tfunction getSource(seriesModel) {\n\t  return inner(seriesModel).source;\n\t}\n\t/**\n\t * MUST be called before mergeOption of all series.\n\t * @param {module:echarts/model/Global} ecModel\n\t */\n\t\n\t\n\tfunction resetSourceDefaulter(ecModel) {\n\t  // `datasetMap` is used to make default encode.\n\t  inner(ecModel).datasetMap = createHashMap();\n\t}\n\t/**\n\t * [Caution]:\n\t * MUST be called after series option merged and\n\t * before \"series.getInitailData()\" called.\n\t *\n\t * [The rule of making default encode]:\n\t * Category axis (if exists) alway map to the first dimension.\n\t * Each other axis occupies a subsequent dimension.\n\t *\n\t * [Why make default encode]:\n\t * Simplify the typing of encode in option, avoiding the case like that:\n\t * series: [{encode: {x: 0, y: 1}}, {encode: {x: 0, y: 2}}, {encode: {x: 0, y: 3}}],\n\t * where the \"y\" have to be manually typed as \"1, 2, 3, ...\".\n\t *\n\t * @param {module:echarts/model/Series} seriesModel\n\t */\n\t\n\t\n\tfunction prepareSource(seriesModel) {\n\t  var seriesOption = seriesModel.option;\n\t  var data = seriesOption.data;\n\t  var sourceFormat = isTypedArray(data) ? SOURCE_FORMAT_TYPED_ARRAY : SOURCE_FORMAT_ORIGINAL;\n\t  var fromDataset = false;\n\t  var seriesLayoutBy = seriesOption.seriesLayoutBy;\n\t  var sourceHeader = seriesOption.sourceHeader;\n\t  var dimensionsDefine = seriesOption.dimensions;\n\t  var datasetModel = getDatasetModel(seriesModel);\n\t\n\t  if (datasetModel) {\n\t    var datasetOption = datasetModel.option;\n\t    data = datasetOption.source;\n\t    sourceFormat = inner(datasetModel).sourceFormat;\n\t    fromDataset = true; // These settings from series has higher priority.\n\t\n\t    seriesLayoutBy = seriesLayoutBy || datasetOption.seriesLayoutBy;\n\t    sourceHeader == null && (sourceHeader = datasetOption.sourceHeader);\n\t    dimensionsDefine = dimensionsDefine || datasetOption.dimensions;\n\t  }\n\t\n\t  var completeResult = completeBySourceData(data, sourceFormat, seriesLayoutBy, sourceHeader, dimensionsDefine); // Note: dataset option does not have `encode`.\n\t\n\t  var encodeDefine = seriesOption.encode;\n\t\n\t  if (!encodeDefine && datasetModel) {\n\t    encodeDefine = makeDefaultEncode(seriesModel, datasetModel, data, sourceFormat, seriesLayoutBy, completeResult);\n\t  }\n\t\n\t  inner(seriesModel).source = new Source({\n\t    data: data,\n\t    fromDataset: fromDataset,\n\t    seriesLayoutBy: seriesLayoutBy,\n\t    sourceFormat: sourceFormat,\n\t    dimensionsDefine: completeResult.dimensionsDefine,\n\t    startIndex: completeResult.startIndex,\n\t    dimensionsDetectCount: completeResult.dimensionsDetectCount,\n\t    encodeDefine: encodeDefine\n\t  });\n\t} // return {startIndex, dimensionsDefine, dimensionsCount}\n\t\n\t\n\tfunction completeBySourceData(data, sourceFormat, seriesLayoutBy, sourceHeader, dimensionsDefine) {\n\t  if (!data) {\n\t    return {\n\t      dimensionsDefine: normalizeDimensionsDefine(dimensionsDefine)\n\t    };\n\t  }\n\t\n\t  var dimensionsDetectCount;\n\t  var startIndex;\n\t  var findPotentialName;\n\t\n\t  if (sourceFormat === SOURCE_FORMAT_ARRAY_ROWS) {\n\t    // Rule: Most of the first line are string: it is header.\n\t    // Caution: consider a line with 5 string and 1 number,\n\t    // it still can not be sure it is a head, because the\n\t    // 5 string may be 5 values of category columns.\n\t    if (sourceHeader === 'auto' || sourceHeader == null) {\n\t      arrayRowsTravelFirst(function (val) {\n\t        // '-' is regarded as null/undefined.\n\t        if (val != null && val !== '-') {\n\t          if (isString(val)) {\n\t            startIndex == null && (startIndex = 1);\n\t          } else {\n\t            startIndex = 0;\n\t          }\n\t        } // 10 is an experience number, avoid long loop.\n\t\n\t      }, seriesLayoutBy, data, 10);\n\t    } else {\n\t      startIndex = sourceHeader ? 1 : 0;\n\t    }\n\t\n\t    if (!dimensionsDefine && startIndex === 1) {\n\t      dimensionsDefine = [];\n\t      arrayRowsTravelFirst(function (val, index) {\n\t        dimensionsDefine[index] = val != null ? val : '';\n\t      }, seriesLayoutBy, data);\n\t    }\n\t\n\t    dimensionsDetectCount = dimensionsDefine ? dimensionsDefine.length : seriesLayoutBy === SERIES_LAYOUT_BY_ROW ? data.length : data[0] ? data[0].length : null;\n\t  } else if (sourceFormat === SOURCE_FORMAT_OBJECT_ROWS) {\n\t    if (!dimensionsDefine) {\n\t      dimensionsDefine = objectRowsCollectDimensions(data);\n\t      findPotentialName = true;\n\t    }\n\t  } else if (sourceFormat === SOURCE_FORMAT_KEYED_COLUMNS) {\n\t    if (!dimensionsDefine) {\n\t      dimensionsDefine = [];\n\t      findPotentialName = true;\n\t      each(data, function (colArr, key) {\n\t        dimensionsDefine.push(key);\n\t      });\n\t    }\n\t  } else if (sourceFormat === SOURCE_FORMAT_ORIGINAL) {\n\t    var value0 = getDataItemValue(data[0]);\n\t    dimensionsDetectCount = isArray(value0) && value0.length || 1;\n\t  } else if (sourceFormat === SOURCE_FORMAT_TYPED_ARRAY) {}\n\t\n\t  var potentialNameDimIndex;\n\t\n\t  if (findPotentialName) {\n\t    each(dimensionsDefine, function (dim, idx) {\n\t      if ((isObject(dim) ? dim.name : dim) === 'name') {\n\t        potentialNameDimIndex = idx;\n\t      }\n\t    });\n\t  }\n\t\n\t  return {\n\t    startIndex: startIndex,\n\t    dimensionsDefine: normalizeDimensionsDefine(dimensionsDefine),\n\t    dimensionsDetectCount: dimensionsDetectCount,\n\t    potentialNameDimIndex: potentialNameDimIndex // TODO: potentialIdDimIdx\n\t\n\t  };\n\t} // Consider dimensions defined like ['A', 'price', 'B', 'price', 'C', 'price'],\n\t// which is reasonable. But dimension name is duplicated.\n\t// Returns undefined or an array contains only object without null/undefiend or string.\n\t\n\t\n\tfunction normalizeDimensionsDefine(dimensionsDefine) {\n\t  if (!dimensionsDefine) {\n\t    // The meaning of null/undefined is different from empty array.\n\t    return;\n\t  }\n\t\n\t  var nameMap = createHashMap();\n\t  return map(dimensionsDefine, function (item, index) {\n\t    item = extend({}, isObject(item) ? item : {\n\t      name: item\n\t    }); // User can set null in dimensions.\n\t    // We dont auto specify name, othewise a given name may\n\t    // cause it be refered unexpectedly.\n\t\n\t    if (item.name == null) {\n\t      return item;\n\t    } // Also consider number form like 2012.\n\t\n\t\n\t    item.name += ''; // User may also specify displayName.\n\t    // displayName will always exists except user not\n\t    // specified or dim name is not specified or detected.\n\t    // (A auto generated dim name will not be used as\n\t    // displayName).\n\t\n\t    if (item.displayName == null) {\n\t      item.displayName = item.name;\n\t    }\n\t\n\t    var exist = nameMap.get(item.name);\n\t\n\t    if (!exist) {\n\t      nameMap.set(item.name, {\n\t        count: 1\n\t      });\n\t    } else {\n\t      item.name += '-' + exist.count++;\n\t    }\n\t\n\t    return item;\n\t  });\n\t}\n\t\n\tfunction arrayRowsTravelFirst(cb, seriesLayoutBy, data, maxLoop) {\n\t  maxLoop == null && (maxLoop = Infinity);\n\t\n\t  if (seriesLayoutBy === SERIES_LAYOUT_BY_ROW) {\n\t    for (var i = 0; i < data.length && i < maxLoop; i++) {\n\t      cb(data[i] ? data[i][0] : null, i);\n\t    }\n\t  } else {\n\t    var value0 = data[0] || [];\n\t\n\t    for (var i = 0; i < value0.length && i < maxLoop; i++) {\n\t      cb(value0[i], i);\n\t    }\n\t  }\n\t}\n\t\n\tfunction objectRowsCollectDimensions(data) {\n\t  var firstIndex = 0;\n\t  var obj;\n\t\n\t  while (firstIndex < data.length && !(obj = data[firstIndex++])) {} // jshint ignore: line\n\t\n\t\n\t  if (obj) {\n\t    var dimensions = [];\n\t    each(obj, function (value, key) {\n\t      dimensions.push(key);\n\t    });\n\t    return dimensions;\n\t  }\n\t} // ??? TODO merge to completedimensions, where also has\n\t// default encode making logic. And the default rule\n\t// should depends on series? consider 'map'.\n\t\n\t\n\tfunction makeDefaultEncode(seriesModel, datasetModel, data, sourceFormat, seriesLayoutBy, completeResult) {\n\t  var coordSysDefine = getCoordSysDefineBySeries(seriesModel);\n\t  var encode = {}; // var encodeTooltip = [];\n\t  // var encodeLabel = [];\n\t\n\t  var encodeItemName = [];\n\t  var encodeSeriesName = [];\n\t  var seriesType = seriesModel.subType; // ??? TODO refactor: provide by series itself.\n\t  // Consider the case: 'map' series is based on geo coordSys,\n\t  // 'graph', 'heatmap' can be based on cartesian. But can not\n\t  // give default rule simply here.\n\t\n\t  var nSeriesMap = createHashMap(['pie', 'map', 'funnel']);\n\t  var cSeriesMap = createHashMap(['line', 'bar', 'pictorialBar', 'scatter', 'effectScatter', 'candlestick', 'boxplot']); // Usually in this case series will use the first data\n\t  // dimension as the \"value\" dimension, or other default\n\t  // processes respectively.\n\t\n\t  if (coordSysDefine && cSeriesMap.get(seriesType) != null) {\n\t    var ecModel = seriesModel.ecModel;\n\t    var datasetMap = inner(ecModel).datasetMap;\n\t    var key = datasetModel.uid + '_' + seriesLayoutBy;\n\t    var datasetRecord = datasetMap.get(key) || datasetMap.set(key, {\n\t      categoryWayDim: 1,\n\t      valueWayDim: 0\n\t    }); // TODO\n\t    // Auto detect first time axis and do arrangement.\n\t\n\t    each(coordSysDefine.coordSysDims, function (coordDim) {\n\t      // In value way.\n\t      if (coordSysDefine.firstCategoryDimIndex == null) {\n\t        var dataDim = datasetRecord.valueWayDim++;\n\t        encode[coordDim] = dataDim; // ??? TODO give a better default series name rule?\n\t        // especially when encode x y specified.\n\t        // consider: when mutiple series share one dimension\n\t        // category axis, series name should better use\n\t        // the other dimsion name. On the other hand, use\n\t        // both dimensions name.\n\t\n\t        encodeSeriesName.push(dataDim); // encodeTooltip.push(dataDim);\n\t        // encodeLabel.push(dataDim);\n\t      } // In category way, category axis.\n\t      else if (coordSysDefine.categoryAxisMap.get(coordDim)) {\n\t          encode[coordDim] = 0;\n\t          encodeItemName.push(0);\n\t        } // In category way, non-category axis.\n\t        else {\n\t            var dataDim = datasetRecord.categoryWayDim++;\n\t            encode[coordDim] = dataDim; // encodeTooltip.push(dataDim);\n\t            // encodeLabel.push(dataDim);\n\t\n\t            encodeSeriesName.push(dataDim);\n\t          }\n\t    });\n\t  } // Do not make a complex rule! Hard to code maintain and not necessary.\n\t  // ??? TODO refactor: provide by series itself.\n\t  // [{name: ..., value: ...}, ...] like:\n\t  else if (nSeriesMap.get(seriesType) != null) {\n\t      // Find the first not ordinal. (5 is an experience value)\n\t      var firstNotOrdinal;\n\t\n\t      for (var i = 0; i < 5 && firstNotOrdinal == null; i++) {\n\t        if (!doGuessOrdinal(data, sourceFormat, seriesLayoutBy, completeResult.dimensionsDefine, completeResult.startIndex, i)) {\n\t          firstNotOrdinal = i;\n\t        }\n\t      }\n\t\n\t      if (firstNotOrdinal != null) {\n\t        encode.value = firstNotOrdinal;\n\t        var nameDimIndex = completeResult.potentialNameDimIndex || Math.max(firstNotOrdinal - 1, 0); // By default, label use itemName in charts.\n\t        // So we dont set encodeLabel here.\n\t\n\t        encodeSeriesName.push(nameDimIndex);\n\t        encodeItemName.push(nameDimIndex); // encodeTooltip.push(firstNotOrdinal);\n\t      }\n\t    } // encodeTooltip.length && (encode.tooltip = encodeTooltip);\n\t  // encodeLabel.length && (encode.label = encodeLabel);\n\t\n\t\n\t  encodeItemName.length && (encode.itemName = encodeItemName);\n\t  encodeSeriesName.length && (encode.seriesName = encodeSeriesName);\n\t  return encode;\n\t}\n\t/**\n\t * If return null/undefined, indicate that should not use datasetModel.\n\t */\n\t\n\t\n\tfunction getDatasetModel(seriesModel) {\n\t  var option = seriesModel.option; // Caution: consider the scenario:\n\t  // A dataset is declared and a series is not expected to use the dataset,\n\t  // and at the beginning `setOption({series: { noData })` (just prepare other\n\t  // option but no data), then `setOption({series: {data: [...]}); In this case,\n\t  // the user should set an empty array to avoid that dataset is used by default.\n\t\n\t  var thisData = option.data;\n\t\n\t  if (!thisData) {\n\t    return seriesModel.ecModel.getComponent('dataset', option.datasetIndex || 0);\n\t  }\n\t}\n\t/**\n\t * The rule should not be complex, otherwise user might not\n\t * be able to known where the data is wrong.\n\t * The code is ugly, but how to make it neat?\n\t *\n\t * @param {module:echars/data/Source} source\n\t * @param {number} dimIndex\n\t * @return {boolean} Whether ordinal.\n\t */\n\t\n\t\n\tfunction guessOrdinal(source, dimIndex) {\n\t  return doGuessOrdinal(source.data, source.sourceFormat, source.seriesLayoutBy, source.dimensionsDefine, source.startIndex, dimIndex);\n\t} // dimIndex may be overflow source data.\n\t\n\t\n\tfunction doGuessOrdinal(data, sourceFormat, seriesLayoutBy, dimensionsDefine, startIndex, dimIndex) {\n\t  var result; // Experience value.\n\t\n\t  var maxLoop = 5;\n\t\n\t  if (isTypedArray(data)) {\n\t    return false;\n\t  } // When sourceType is 'objectRows' or 'keyedColumns', dimensionsDefine\n\t  // always exists in source.\n\t\n\t\n\t  var dimName;\n\t\n\t  if (dimensionsDefine) {\n\t    dimName = dimensionsDefine[dimIndex];\n\t    dimName = isObject(dimName) ? dimName.name : dimName;\n\t  }\n\t\n\t  if (sourceFormat === SOURCE_FORMAT_ARRAY_ROWS) {\n\t    if (seriesLayoutBy === SERIES_LAYOUT_BY_ROW) {\n\t      var sample = data[dimIndex];\n\t\n\t      for (var i = 0; i < (sample || []).length && i < maxLoop; i++) {\n\t        if ((result = detectValue(sample[startIndex + i])) != null) {\n\t          return result;\n\t        }\n\t      }\n\t    } else {\n\t      for (var i = 0; i < data.length && i < maxLoop; i++) {\n\t        var row = data[startIndex + i];\n\t\n\t        if (row && (result = detectValue(row[dimIndex])) != null) {\n\t          return result;\n\t        }\n\t      }\n\t    }\n\t  } else if (sourceFormat === SOURCE_FORMAT_OBJECT_ROWS) {\n\t    if (!dimName) {\n\t      return;\n\t    }\n\t\n\t    for (var i = 0; i < data.length && i < maxLoop; i++) {\n\t      var item = data[i];\n\t\n\t      if (item && (result = detectValue(item[dimName])) != null) {\n\t        return result;\n\t      }\n\t    }\n\t  } else if (sourceFormat === SOURCE_FORMAT_KEYED_COLUMNS) {\n\t    if (!dimName) {\n\t      return;\n\t    }\n\t\n\t    var sample = data[dimName];\n\t\n\t    if (!sample || isTypedArray(sample)) {\n\t      return false;\n\t    }\n\t\n\t    for (var i = 0; i < sample.length && i < maxLoop; i++) {\n\t      if ((result = detectValue(sample[i])) != null) {\n\t        return result;\n\t      }\n\t    }\n\t  } else if (sourceFormat === SOURCE_FORMAT_ORIGINAL) {\n\t    for (var i = 0; i < data.length && i < maxLoop; i++) {\n\t      var item = data[i];\n\t      var val = getDataItemValue(item);\n\t\n\t      if (!isArray(val)) {\n\t        return false;\n\t      }\n\t\n\t      if ((result = detectValue(val[dimIndex])) != null) {\n\t        return result;\n\t      }\n\t    }\n\t  }\n\t\n\t  function detectValue(val) {\n\t    // Consider usage convenience, '1', '2' will be treated as \"number\".\n\t    // `isFinit('')` get `true`.\n\t    if (val != null && isFinite(val) && val !== '') {\n\t      return false;\n\t    } else if (isString(val) && val !== '-') {\n\t      return true;\n\t    }\n\t  }\n\t\n\t  return false;\n\t}\n\t\n\texports.detectSourceFormat = detectSourceFormat;\n\texports.getSource = getSource;\n\texports.resetSourceDefaulter = resetSourceDefaulter;\n\texports.prepareSource = prepareSource;\n\texports.guessOrdinal = guessOrdinal;\n\n/***/ },\n/* 30 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar _config = __webpack_require__(6);\n\t\n\tvar __DEV__ = _config.__DEV__;\n\t\n\tvar _util = __webpack_require__(1);\n\t\n\tvar createHashMap = _util.createHashMap;\n\tvar retrieve = _util.retrieve;\n\tvar each = _util.each;\n\t\n\t/**\n\t * Helper for model references.\n\t * There are many manners to refer axis/coordSys.\n\t */\n\t// TODO\n\t// merge relevant logic to this file?\n\t// check: \"modelHelper\" of tooltip and \"BrushTargetManager\".\n\t\n\t/**\n\t * @return {Object} For example:\n\t * {\n\t *     coordSysName: 'cartesian2d',\n\t *     coordSysDims: ['x', 'y', ...],\n\t *     axisMap: HashMap({\n\t *         x: xAxisModel,\n\t *         y: yAxisModel\n\t *     }),\n\t *     categoryAxisMap: HashMap({\n\t *         x: xAxisModel,\n\t *         y: undefined\n\t *     }),\n\t *     // It also indicate that whether there is category axis.\n\t *     firstCategoryDimIndex: 1,\n\t *     // To replace user specified encode.\n\t * }\n\t */\n\tfunction getCoordSysDefineBySeries(seriesModel) {\n\t  var coordSysName = seriesModel.get('coordinateSystem');\n\t  var result = {\n\t    coordSysName: coordSysName,\n\t    coordSysDims: [],\n\t    axisMap: createHashMap(),\n\t    categoryAxisMap: createHashMap()\n\t  };\n\t  var fetch = fetchers[coordSysName];\n\t\n\t  if (fetch) {\n\t    fetch(seriesModel, result, result.axisMap, result.categoryAxisMap);\n\t    return result;\n\t  }\n\t}\n\t\n\tvar fetchers = {\n\t  cartesian2d: function (seriesModel, result, axisMap, categoryAxisMap) {\n\t    var xAxisModel = seriesModel.getReferringComponents('xAxis')[0];\n\t    var yAxisModel = seriesModel.getReferringComponents('yAxis')[0];\n\t    result.coordSysDims = ['x', 'y'];\n\t    axisMap.set('x', xAxisModel);\n\t    axisMap.set('y', yAxisModel);\n\t\n\t    if (isCategory(xAxisModel)) {\n\t      categoryAxisMap.set('x', xAxisModel);\n\t      result.firstCategoryDimIndex = 0;\n\t    }\n\t\n\t    if (isCategory(yAxisModel)) {\n\t      categoryAxisMap.set('y', yAxisModel);\n\t      result.firstCategoryDimIndex = 1;\n\t    }\n\t  },\n\t  singleAxis: function (seriesModel, result, axisMap, categoryAxisMap) {\n\t    var singleAxisModel = seriesModel.getReferringComponents('singleAxis')[0];\n\t    result.coordSysDims = ['single'];\n\t    axisMap.set('single', singleAxisModel);\n\t\n\t    if (isCategory(singleAxisModel)) {\n\t      categoryAxisMap.set('single', singleAxisModel);\n\t      result.firstCategoryDimIndex = 0;\n\t    }\n\t  },\n\t  polar: function (seriesModel, result, axisMap, categoryAxisMap) {\n\t    var polarModel = seriesModel.getReferringComponents('polar')[0];\n\t    var radiusAxisModel = polarModel.findAxisModel('radiusAxis');\n\t    var angleAxisModel = polarModel.findAxisModel('angleAxis');\n\t    result.coordSysDims = ['radius', 'angle'];\n\t    axisMap.set('radius', radiusAxisModel);\n\t    axisMap.set('angle', angleAxisModel);\n\t\n\t    if (isCategory(radiusAxisModel)) {\n\t      categoryAxisMap.set('radius', radiusAxisModel);\n\t      result.firstCategoryDimIndex = 0;\n\t    }\n\t\n\t    if (isCategory(angleAxisModel)) {\n\t      categoryAxisMap.set('angle', angleAxisModel);\n\t      result.firstCategoryDimIndex = 1;\n\t    }\n\t  },\n\t  geo: function (seriesModel, result, axisMap, categoryAxisMap) {\n\t    result.coordSysDims = ['lng', 'lat'];\n\t  },\n\t  parallel: function (seriesModel, result, axisMap, categoryAxisMap) {\n\t    var ecModel = seriesModel.ecModel;\n\t    var parallelModel = ecModel.getComponent('parallel', seriesModel.get('parallelIndex'));\n\t    var coordSysDims = result.coordSysDims = parallelModel.dimensions.slice();\n\t    each(parallelModel.parallelAxisIndex, function (axisIndex, index) {\n\t      var axisModel = ecModel.getComponent('parallelAxis', axisIndex);\n\t      var axisDim = coordSysDims[index];\n\t      axisMap.set(axisDim, axisModel);\n\t\n\t      if (isCategory(axisModel) && result.firstCategoryDimIndex == null) {\n\t        categoryAxisMap.set(axisDim, axisModel);\n\t        result.firstCategoryDimIndex = index;\n\t      }\n\t    });\n\t  }\n\t};\n\t\n\tfunction isCategory(axisModel) {\n\t  return axisModel.get('type') === 'category';\n\t}\n\t\n\texports.getCoordSysDefineBySeries = getCoordSysDefineBySeries;\n\n/***/ },\n/* 31 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar _config = __webpack_require__(6);\n\t\n\tvar __DEV__ = _config.__DEV__;\n\t\n\tvar zrUtil = __webpack_require__(1);\n\t\n\tvar TYPE_DELIMITER = '.';\n\tvar IS_CONTAINER = '___EC__COMPONENT__CONTAINER___';\n\t/**\n\t * Notice, parseClassType('') should returns {main: '', sub: ''}\n\t * @public\n\t */\n\t\n\tfunction parseClassType(componentType) {\n\t  var ret = {\n\t    main: '',\n\t    sub: ''\n\t  };\n\t\n\t  if (componentType) {\n\t    componentType = componentType.split(TYPE_DELIMITER);\n\t    ret.main = componentType[0] || '';\n\t    ret.sub = componentType[1] || '';\n\t  }\n\t\n\t  return ret;\n\t}\n\t/**\n\t * @public\n\t */\n\t\n\t\n\tfunction checkClassType(componentType) {\n\t  zrUtil.assert(/^[a-zA-Z0-9_]+([.][a-zA-Z0-9_]+)?$/.test(componentType), 'componentType \"' + componentType + '\" illegal');\n\t}\n\t/**\n\t * @public\n\t */\n\t\n\t\n\tfunction enableClassExtend(RootClass, mandatoryMethods) {\n\t  RootClass.$constructor = RootClass;\n\t\n\t  RootClass.extend = function (proto) {\n\t    var superClass = this;\n\t\n\t    var ExtendedClass = function () {\n\t      if (!proto.$constructor) {\n\t        superClass.apply(this, arguments);\n\t      } else {\n\t        proto.$constructor.apply(this, arguments);\n\t      }\n\t    };\n\t\n\t    zrUtil.extend(ExtendedClass.prototype, proto);\n\t    ExtendedClass.extend = this.extend;\n\t    ExtendedClass.superCall = superCall;\n\t    ExtendedClass.superApply = superApply;\n\t    zrUtil.inherits(ExtendedClass, this);\n\t    ExtendedClass.superClass = superClass;\n\t    return ExtendedClass;\n\t  };\n\t}\n\t\n\tvar classBase = 0;\n\t/**\n\t * Can not use instanceof, consider different scope by\n\t * cross domain or es module import in ec extensions.\n\t * Mount a method \"isInstance()\" to Clz.\n\t */\n\t\n\tfunction enableClassCheck(Clz) {\n\t  var classAttr = ['__\\0is_clz', classBase++, Math.random().toFixed(3)].join('_');\n\t  Clz.prototype[classAttr] = true;\n\t\n\t  Clz.isInstance = function (obj) {\n\t    return !!(obj && obj[classAttr]);\n\t  };\n\t} // superCall should have class info, which can not be fetch from 'this'.\n\t// Consider this case:\n\t// class A has method f,\n\t// class B inherits class A, overrides method f, f call superApply('f'),\n\t// class C inherits class B, do not overrides method f,\n\t// then when method of class C is called, dead loop occured.\n\t\n\t\n\tfunction superCall(context, methodName) {\n\t  var args = zrUtil.slice(arguments, 2);\n\t  return this.superClass.prototype[methodName].apply(context, args);\n\t}\n\t\n\tfunction superApply(context, methodName, args) {\n\t  return this.superClass.prototype[methodName].apply(context, args);\n\t}\n\t/**\n\t * @param {Object} entity\n\t * @param {Object} options\n\t * @param {boolean} [options.registerWhenExtend]\n\t * @public\n\t */\n\t\n\t\n\tfunction enableClassManagement(entity, options) {\n\t  options = options || {};\n\t  /**\n\t   * Component model classes\n\t   * key: componentType,\n\t   * value:\n\t   *     componentClass, when componentType is 'xxx'\n\t   *     or Object.<subKey, componentClass>, when componentType is 'xxx.yy'\n\t   * @type {Object}\n\t   */\n\t\n\t  var storage = {};\n\t\n\t  entity.registerClass = function (Clazz, componentType) {\n\t    if (componentType) {\n\t      checkClassType(componentType);\n\t      componentType = parseClassType(componentType);\n\t\n\t      if (!componentType.sub) {\n\t        storage[componentType.main] = Clazz;\n\t      } else if (componentType.sub !== IS_CONTAINER) {\n\t        var container = makeContainer(componentType);\n\t        container[componentType.sub] = Clazz;\n\t      }\n\t    }\n\t\n\t    return Clazz;\n\t  };\n\t\n\t  entity.getClass = function (componentMainType, subType, throwWhenNotFound) {\n\t    var Clazz = storage[componentMainType];\n\t\n\t    if (Clazz && Clazz[IS_CONTAINER]) {\n\t      Clazz = subType ? Clazz[subType] : null;\n\t    }\n\t\n\t    if (throwWhenNotFound && !Clazz) {\n\t      throw new Error(!subType ? componentMainType + '.' + 'type should be specified.' : 'Component ' + componentMainType + '.' + (subType || '') + ' not exists. Load it first.');\n\t    }\n\t\n\t    return Clazz;\n\t  };\n\t\n\t  entity.getClassesByMainType = function (componentType) {\n\t    componentType = parseClassType(componentType);\n\t    var result = [];\n\t    var obj = storage[componentType.main];\n\t\n\t    if (obj && obj[IS_CONTAINER]) {\n\t      zrUtil.each(obj, function (o, type) {\n\t        type !== IS_CONTAINER && result.push(o);\n\t      });\n\t    } else {\n\t      result.push(obj);\n\t    }\n\t\n\t    return result;\n\t  };\n\t\n\t  entity.hasClass = function (componentType) {\n\t    // Just consider componentType.main.\n\t    componentType = parseClassType(componentType);\n\t    return !!storage[componentType.main];\n\t  };\n\t  /**\n\t   * @return {Array.<string>} Like ['aa', 'bb'], but can not be ['aa.xx']\n\t   */\n\t\n\t\n\t  entity.getAllClassMainTypes = function () {\n\t    var types = [];\n\t    zrUtil.each(storage, function (obj, type) {\n\t      types.push(type);\n\t    });\n\t    return types;\n\t  };\n\t  /**\n\t   * If a main type is container and has sub types\n\t   * @param  {string}  mainType\n\t   * @return {boolean}\n\t   */\n\t\n\t\n\t  entity.hasSubTypes = function (componentType) {\n\t    componentType = parseClassType(componentType);\n\t    var obj = storage[componentType.main];\n\t    return obj && obj[IS_CONTAINER];\n\t  };\n\t\n\t  entity.parseClassType = parseClassType;\n\t\n\t  function makeContainer(componentType) {\n\t    var container = storage[componentType.main];\n\t\n\t    if (!container || !container[IS_CONTAINER]) {\n\t      container = storage[componentType.main] = {};\n\t      container[IS_CONTAINER] = true;\n\t    }\n\t\n\t    return container;\n\t  }\n\t\n\t  if (options.registerWhenExtend) {\n\t    var originalExtend = entity.extend;\n\t\n\t    if (originalExtend) {\n\t      entity.extend = function (proto) {\n\t        var ExtendedClass = originalExtend.call(this, proto);\n\t        return entity.registerClass(ExtendedClass, proto.type);\n\t      };\n\t    }\n\t  }\n\t\n\t  return entity;\n\t}\n\t/**\n\t * @param {string|Array.<string>} properties\n\t */\n\t\n\t\n\tfunction setReadOnly(obj, properties) {// FIXME It seems broken in IE8 simulation of IE11\n\t  // if (!zrUtil.isArray(properties)) {\n\t  //     properties = properties != null ? [properties] : [];\n\t  // }\n\t  // zrUtil.each(properties, function (prop) {\n\t  //     var value = obj[prop];\n\t  //     Object.defineProperty\n\t  //         && Object.defineProperty(obj, prop, {\n\t  //             value: value, writable: false\n\t  //         });\n\t  //     zrUtil.isArray(obj[prop])\n\t  //         && Object.freeze\n\t  //         && Object.freeze(obj[prop]);\n\t  // });\n\t}\n\t\n\texports.parseClassType = parseClassType;\n\texports.enableClassExtend = enableClassExtend;\n\texports.enableClassCheck = enableClassCheck;\n\texports.enableClassManagement = enableClassManagement;\n\texports.setReadOnly = setReadOnly;\n\n/***/ },\n/* 32 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar zrUtil = __webpack_require__(1);\n\t\n\tvar pathTool = __webpack_require__(72);\n\t\n\tvar colorTool = __webpack_require__(26);\n\t\n\tvar matrix = __webpack_require__(10);\n\t\n\tvar vector = __webpack_require__(3);\n\t\n\tvar Path = __webpack_require__(2);\n\t\n\tvar Transformable = __webpack_require__(25);\n\t\n\tvar ZImage = __webpack_require__(50);\n\t\n\texports.Image = ZImage;\n\t\n\tvar Group = __webpack_require__(44);\n\t\n\texports.Group = Group;\n\t\n\tvar Text = __webpack_require__(56);\n\t\n\texports.Text = Text;\n\t\n\tvar Circle = __webpack_require__(63);\n\t\n\texports.Circle = Circle;\n\t\n\tvar Sector = __webpack_require__(69);\n\t\n\texports.Sector = Sector;\n\t\n\tvar Ring = __webpack_require__(68);\n\t\n\texports.Ring = Ring;\n\t\n\tvar Polygon = __webpack_require__(65);\n\t\n\texports.Polygon = Polygon;\n\t\n\tvar Polyline = __webpack_require__(66);\n\t\n\texports.Polyline = Polyline;\n\t\n\tvar Rect = __webpack_require__(67);\n\t\n\texports.Rect = Rect;\n\t\n\tvar Line = __webpack_require__(64);\n\t\n\texports.Line = Line;\n\t\n\tvar BezierCurve = __webpack_require__(62);\n\t\n\texports.BezierCurve = BezierCurve;\n\t\n\tvar Arc = __webpack_require__(61);\n\t\n\texports.Arc = Arc;\n\t\n\tvar CompoundPath = __webpack_require__(49);\n\t\n\texports.CompoundPath = CompoundPath;\n\t\n\tvar LinearGradient = __webpack_require__(52);\n\t\n\texports.LinearGradient = LinearGradient;\n\t\n\tvar RadialGradient = __webpack_require__(54);\n\t\n\texports.RadialGradient = RadialGradient;\n\t\n\tvar BoundingRect = __webpack_require__(4);\n\t\n\texports.BoundingRect = BoundingRect;\n\t\n\tvar IncrementalDisplayable = __webpack_require__(51);\n\t\n\texports.IncrementalDisplayable = IncrementalDisplayable;\n\tvar round = Math.round;\n\tvar mathMax = Math.max;\n\tvar mathMin = Math.min;\n\tvar EMPTY_OBJ = {};\n\t/**\n\t * Extend shape with parameters\n\t */\n\t\n\tfunction extendShape(opts) {\n\t  return Path.extend(opts);\n\t}\n\t/**\n\t * Extend path\n\t */\n\t\n\t\n\tfunction extendPath(pathData, opts) {\n\t  return pathTool.extendFromString(pathData, opts);\n\t}\n\t/**\n\t * Create a path element from path data string\n\t * @param {string} pathData\n\t * @param {Object} opts\n\t * @param {module:zrender/core/BoundingRect} rect\n\t * @param {string} [layout=cover] 'center' or 'cover'\n\t */\n\t\n\t\n\tfunction makePath(pathData, opts, rect, layout) {\n\t  var path = pathTool.createFromString(pathData, opts);\n\t  var boundingRect = path.getBoundingRect();\n\t\n\t  if (rect) {\n\t    if (layout === 'center') {\n\t      rect = centerGraphic(rect, boundingRect);\n\t    }\n\t\n\t    resizePath(path, rect);\n\t  }\n\t\n\t  return path;\n\t}\n\t/**\n\t * Create a image element from image url\n\t * @param {string} imageUrl image url\n\t * @param {Object} opts options\n\t * @param {module:zrender/core/BoundingRect} rect constrain rect\n\t * @param {string} [layout=cover] 'center' or 'cover'\n\t */\n\t\n\t\n\tfunction makeImage(imageUrl, rect, layout) {\n\t  var path = new ZImage({\n\t    style: {\n\t      image: imageUrl,\n\t      x: rect.x,\n\t      y: rect.y,\n\t      width: rect.width,\n\t      height: rect.height\n\t    },\n\t    onload: function (img) {\n\t      if (layout === 'center') {\n\t        var boundingRect = {\n\t          width: img.width,\n\t          height: img.height\n\t        };\n\t        path.setStyle(centerGraphic(rect, boundingRect));\n\t      }\n\t    }\n\t  });\n\t  return path;\n\t}\n\t/**\n\t * Get position of centered element in bounding box.\n\t *\n\t * @param  {Object} rect         element local bounding box\n\t * @param  {Object} boundingRect constraint bounding box\n\t * @return {Object} element position containing x, y, width, and height\n\t */\n\t\n\t\n\tfunction centerGraphic(rect, boundingRect) {\n\t  // Set rect to center, keep width / height ratio.\n\t  var aspect = boundingRect.width / boundingRect.height;\n\t  var width = rect.height * aspect;\n\t  var height;\n\t\n\t  if (width <= rect.width) {\n\t    height = rect.height;\n\t  } else {\n\t    width = rect.width;\n\t    height = width / aspect;\n\t  }\n\t\n\t  var cx = rect.x + rect.width / 2;\n\t  var cy = rect.y + rect.height / 2;\n\t  return {\n\t    x: cx - width / 2,\n\t    y: cy - height / 2,\n\t    width: width,\n\t    height: height\n\t  };\n\t}\n\t\n\tvar mergePath = pathTool.mergePath;\n\t/**\n\t * Resize a path to fit the rect\n\t * @param {module:zrender/graphic/Path} path\n\t * @param {Object} rect\n\t */\n\t\n\tfunction resizePath(path, rect) {\n\t  if (!path.applyTransform) {\n\t    return;\n\t  }\n\t\n\t  var pathRect = path.getBoundingRect();\n\t  var m = pathRect.calculateTransform(rect);\n\t  path.applyTransform(m);\n\t}\n\t/**\n\t * Sub pixel optimize line for canvas\n\t *\n\t * @param {Object} param\n\t * @param {Object} [param.shape]\n\t * @param {number} [param.shape.x1]\n\t * @param {number} [param.shape.y1]\n\t * @param {number} [param.shape.x2]\n\t * @param {number} [param.shape.y2]\n\t * @param {Object} [param.style]\n\t * @param {number} [param.style.lineWidth]\n\t * @return {Object} Modified param\n\t */\n\t\n\t\n\tfunction subPixelOptimizeLine(param) {\n\t  var shape = param.shape;\n\t  var lineWidth = param.style.lineWidth;\n\t\n\t  if (round(shape.x1 * 2) === round(shape.x2 * 2)) {\n\t    shape.x1 = shape.x2 = subPixelOptimize(shape.x1, lineWidth, true);\n\t  }\n\t\n\t  if (round(shape.y1 * 2) === round(shape.y2 * 2)) {\n\t    shape.y1 = shape.y2 = subPixelOptimize(shape.y1, lineWidth, true);\n\t  }\n\t\n\t  return param;\n\t}\n\t/**\n\t * Sub pixel optimize rect for canvas\n\t *\n\t * @param {Object} param\n\t * @param {Object} [param.shape]\n\t * @param {number} [param.shape.x]\n\t * @param {number} [param.shape.y]\n\t * @param {number} [param.shape.width]\n\t * @param {number} [param.shape.height]\n\t * @param {Object} [param.style]\n\t * @param {number} [param.style.lineWidth]\n\t * @return {Object} Modified param\n\t */\n\t\n\t\n\tfunction subPixelOptimizeRect(param) {\n\t  var shape = param.shape;\n\t  var lineWidth = param.style.lineWidth;\n\t  var originX = shape.x;\n\t  var originY = shape.y;\n\t  var originWidth = shape.width;\n\t  var originHeight = shape.height;\n\t  shape.x = subPixelOptimize(shape.x, lineWidth, true);\n\t  shape.y = subPixelOptimize(shape.y, lineWidth, true);\n\t  shape.width = Math.max(subPixelOptimize(originX + originWidth, lineWidth, false) - shape.x, originWidth === 0 ? 0 : 1);\n\t  shape.height = Math.max(subPixelOptimize(originY + originHeight, lineWidth, false) - shape.y, originHeight === 0 ? 0 : 1);\n\t  return param;\n\t}\n\t/**\n\t * Sub pixel optimize for canvas\n\t *\n\t * @param {number} position Coordinate, such as x, y\n\t * @param {number} lineWidth Should be nonnegative integer.\n\t * @param {boolean=} positiveOrNegative Default false (negative).\n\t * @return {number} Optimized position.\n\t */\n\t\n\t\n\tfunction subPixelOptimize(position, lineWidth, positiveOrNegative) {\n\t  // Assure that (position + lineWidth / 2) is near integer edge,\n\t  // otherwise line will be fuzzy in canvas.\n\t  var doubledPosition = round(position * 2);\n\t  return (doubledPosition + round(lineWidth)) % 2 === 0 ? doubledPosition / 2 : (doubledPosition + (positiveOrNegative ? 1 : -1)) / 2;\n\t}\n\t\n\tfunction hasFillOrStroke(fillOrStroke) {\n\t  return fillOrStroke != null && fillOrStroke != 'none';\n\t}\n\t\n\tfunction liftColor(color) {\n\t  return typeof color === 'string' ? colorTool.lift(color, -0.1) : color;\n\t}\n\t/**\n\t * @private\n\t */\n\t\n\t\n\tfunction cacheElementStl(el) {\n\t  if (el.__hoverStlDirty) {\n\t    var stroke = el.style.stroke;\n\t    var fill = el.style.fill; // Create hoverStyle on mouseover\n\t\n\t    var hoverStyle = el.__hoverStl;\n\t    hoverStyle.fill = hoverStyle.fill || (hasFillOrStroke(fill) ? liftColor(fill) : null);\n\t    hoverStyle.stroke = hoverStyle.stroke || (hasFillOrStroke(stroke) ? liftColor(stroke) : null);\n\t    var normalStyle = {};\n\t\n\t    for (var name in hoverStyle) {\n\t      // See comment in `doSingleEnterHover`.\n\t      if (hoverStyle[name] != null) {\n\t        normalStyle[name] = el.style[name];\n\t      }\n\t    }\n\t\n\t    el.__normalStl = normalStyle;\n\t    el.__hoverStlDirty = false;\n\t  }\n\t}\n\t/**\n\t * @private\n\t */\n\t\n\t\n\tfunction doSingleEnterHover(el) {\n\t  if (el.__isHover) {\n\t    return;\n\t  }\n\t\n\t  cacheElementStl(el);\n\t\n\t  if (el.useHoverLayer) {\n\t    el.__zr && el.__zr.addHover(el, el.__hoverStl);\n\t  } else {\n\t    var style = el.style;\n\t    var insideRollbackOpt = style.insideRollbackOpt; // Consider case: only `position: 'top'` is set on emphasis, then text\n\t    // color should be returned to `autoColor`, rather than remain '#fff'.\n\t    // So we should rollback then apply again after style merging.\n\t\n\t    insideRollbackOpt && rollbackInsideStyle(style); // styles can be:\n\t    // {\n\t    //    label: {\n\t    //        show: false,\n\t    //        position: 'outside',\n\t    //        fontSize: 18\n\t    //    },\n\t    //    emphasis: {\n\t    //        label: {\n\t    //            show: true\n\t    //        }\n\t    //    }\n\t    // },\n\t    // where properties of `emphasis` may not appear in `normal`. We previously use\n\t    // module:echarts/util/model#defaultEmphasis to merge `normal` to `emphasis`.\n\t    // But consider rich text and setOption in merge mode, it is impossible to cover\n\t    // all properties in merge. So we use merge mode when setting style here, where\n\t    // only properties that is not `null/undefined` can be set. The disadventage:\n\t    // null/undefined can not be used to remove style any more in `emphasis`.\n\t\n\t    style.extendFrom(el.__hoverStl); // Do not save `insideRollback`.\n\t\n\t    if (insideRollbackOpt) {\n\t      applyInsideStyle(style, style.insideOriginalTextPosition, insideRollbackOpt); // textFill may be rollbacked to null.\n\t\n\t      if (style.textFill == null) {\n\t        style.textFill = insideRollbackOpt.autoColor;\n\t      }\n\t    }\n\t\n\t    el.dirty(false);\n\t    el.z2 += 1;\n\t  }\n\t\n\t  el.__isHover = true;\n\t}\n\t/**\n\t * @inner\n\t */\n\t\n\t\n\tfunction doSingleLeaveHover(el) {\n\t  if (!el.__isHover) {\n\t    return;\n\t  }\n\t\n\t  var normalStl = el.__normalStl;\n\t\n\t  if (el.useHoverLayer) {\n\t    el.__zr && el.__zr.removeHover(el);\n\t  } else {\n\t    // Consider null/undefined value, should use\n\t    // `setStyle` but not `extendFrom(stl, true)`.\n\t    normalStl && el.setStyle(normalStl);\n\t    el.z2 -= 1;\n\t  }\n\t\n\t  el.__isHover = false;\n\t}\n\t/**\n\t * @inner\n\t */\n\t\n\t\n\tfunction doEnterHover(el) {\n\t  el.type === 'group' ? el.traverse(function (child) {\n\t    if (child.type !== 'group') {\n\t      doSingleEnterHover(child);\n\t    }\n\t  }) : doSingleEnterHover(el);\n\t}\n\t\n\tfunction doLeaveHover(el) {\n\t  el.type === 'group' ? el.traverse(function (child) {\n\t    if (child.type !== 'group') {\n\t      doSingleLeaveHover(child);\n\t    }\n\t  }) : doSingleLeaveHover(el);\n\t}\n\t/**\n\t * @inner\n\t */\n\t\n\t\n\tfunction setElementHoverStl(el, hoverStl) {\n\t  // If element has sepcified hoverStyle, then use it instead of given hoverStyle\n\t  // Often used when item group has a label element and it's hoverStyle is different\n\t  el.__hoverStl = el.hoverStyle || hoverStl || {};\n\t  el.__hoverStlDirty = true;\n\t\n\t  if (el.__isHover) {\n\t    cacheElementStl(el);\n\t  }\n\t}\n\t/**\n\t * @inner\n\t */\n\t\n\t\n\tfunction onElementMouseOver(e) {\n\t  if (this.__hoverSilentOnTouch && e.zrByTouch) {\n\t    return;\n\t  } // Only if element is not in emphasis status\n\t\n\t\n\t  !this.__isEmphasis && doEnterHover(this);\n\t}\n\t/**\n\t * @inner\n\t */\n\t\n\t\n\tfunction onElementMouseOut(e) {\n\t  if (this.__hoverSilentOnTouch && e.zrByTouch) {\n\t    return;\n\t  } // Only if element is not in emphasis status\n\t\n\t\n\t  !this.__isEmphasis && doLeaveHover(this);\n\t}\n\t/**\n\t * @inner\n\t */\n\t\n\t\n\tfunction enterEmphasis() {\n\t  this.__isEmphasis = true;\n\t  doEnterHover(this);\n\t}\n\t/**\n\t * @inner\n\t */\n\t\n\t\n\tfunction leaveEmphasis() {\n\t  this.__isEmphasis = false;\n\t  doLeaveHover(this);\n\t}\n\t/**\n\t * Set hover style of element.\n\t * This method can be called repeatly without side-effects.\n\t * @param {module:zrender/Element} el\n\t * @param {Object} [hoverStyle]\n\t * @param {Object} [opt]\n\t * @param {boolean} [opt.hoverSilentOnTouch=false]\n\t *        In touch device, mouseover event will be trigger on touchstart event\n\t *        (see module:zrender/dom/HandlerProxy). By this mechanism, we can\n\t *        conviniently use hoverStyle when tap on touch screen without additional\n\t *        code for compatibility.\n\t *        But if the chart/component has select feature, which usually also use\n\t *        hoverStyle, there might be conflict between 'select-highlight' and\n\t *        'hover-highlight' especially when roam is enabled (see geo for example).\n\t *        In this case, hoverSilentOnTouch should be used to disable hover-highlight\n\t *        on touch device.\n\t */\n\t\n\t\n\tfunction setHoverStyle(el, hoverStyle, opt) {\n\t  el.__hoverSilentOnTouch = opt && opt.hoverSilentOnTouch;\n\t  el.type === 'group' ? el.traverse(function (child) {\n\t    if (child.type !== 'group') {\n\t      setElementHoverStl(child, hoverStyle);\n\t    }\n\t  }) : setElementHoverStl(el, hoverStyle); // Duplicated function will be auto-ignored, see Eventful.js.\n\t\n\t  el.on('mouseover', onElementMouseOver).on('mouseout', onElementMouseOut); // Emphasis, normal can be triggered manually\n\t\n\t  el.on('emphasis', enterEmphasis).on('normal', leaveEmphasis);\n\t}\n\t/**\n\t * @param {Object|module:zrender/graphic/Style} normalStyle\n\t * @param {Object} emphasisStyle\n\t * @param {module:echarts/model/Model} normalModel\n\t * @param {module:echarts/model/Model} emphasisModel\n\t * @param {Object} opt Check `opt` of `setTextStyleCommon` to find other props.\n\t * @param {string|Function} [opt.defaultText]\n\t * @param {module:echarts/model/Model} [opt.labelFetcher] Fetch text by\n\t *      `opt.labelFetcher.getFormattedLabel(opt.labelDataIndex, 'normal'/'emphasis', null, opt.labelDimIndex)`\n\t * @param {module:echarts/model/Model} [opt.labelDataIndex] Fetch text by\n\t *      `opt.textFetcher.getFormattedLabel(opt.labelDataIndex, 'normal'/'emphasis', null, opt.labelDimIndex)`\n\t * @param {module:echarts/model/Model} [opt.labelDimIndex] Fetch text by\n\t *      `opt.textFetcher.getFormattedLabel(opt.labelDataIndex, 'normal'/'emphasis', null, opt.labelDimIndex)`\n\t * @param {Object} [normalSpecified]\n\t * @param {Object} [emphasisSpecified]\n\t */\n\t\n\t\n\tfunction setLabelStyle(normalStyle, emphasisStyle, normalModel, emphasisModel, opt, normalSpecified, emphasisSpecified) {\n\t  opt = opt || EMPTY_OBJ;\n\t  var labelFetcher = opt.labelFetcher;\n\t  var labelDataIndex = opt.labelDataIndex;\n\t  var labelDimIndex = opt.labelDimIndex; // This scenario, `label.normal.show = true; label.emphasis.show = false`,\n\t  // is not supported util someone requests.\n\t\n\t  var showNormal = normalModel.getShallow('show');\n\t  var showEmphasis = emphasisModel.getShallow('show'); // Consider performance, only fetch label when necessary.\n\t  // If `normal.show` is `false` and `emphasis.show` is `true` and `emphasis.formatter` is not set,\n\t  // label should be displayed, where text is fetched by `normal.formatter` or `opt.defaultText`.\n\t\n\t  var baseText;\n\t\n\t  if (showNormal || showEmphasis) {\n\t    if (labelFetcher) {\n\t      baseText = labelFetcher.getFormattedLabel(labelDataIndex, 'normal', null, labelDimIndex);\n\t    }\n\t\n\t    if (baseText == null) {\n\t      baseText = zrUtil.isFunction(opt.defaultText) ? opt.defaultText(labelDataIndex, opt) : opt.defaultText;\n\t    }\n\t  }\n\t\n\t  var normalStyleText = showNormal ? baseText : null;\n\t  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\t\n\t  if (normalStyleText != null || emphasisStyleText != null) {\n\t    // Always set `textStyle` even if `normalStyle.text` is null, because default\n\t    // values have to be set on `normalStyle`.\n\t    // If we set default values on `emphasisStyle`, consider case:\n\t    // Firstly, `setOption(... label: {normal: {text: null}, emphasis: {show: true}} ...);`\n\t    // Secondly, `setOption(... label: {noraml: {show: true, text: 'abc', color: 'red'} ...);`\n\t    // Then the 'red' will not work on emphasis.\n\t    setTextStyle(normalStyle, normalModel, normalSpecified, opt);\n\t    setTextStyle(emphasisStyle, emphasisModel, emphasisSpecified, opt, true);\n\t  }\n\t\n\t  normalStyle.text = normalStyleText;\n\t  emphasisStyle.text = emphasisStyleText;\n\t}\n\t/**\n\t * Set basic textStyle properties.\n\t * @param {Object|module:zrender/graphic/Style} textStyle\n\t * @param {module:echarts/model/Model} model\n\t * @param {Object} [specifiedTextStyle] Can be overrided by settings in model.\n\t * @param {Object} [opt] See `opt` of `setTextStyleCommon`.\n\t * @param {boolean} [isEmphasis]\n\t */\n\t\n\t\n\tfunction setTextStyle(textStyle, textStyleModel, specifiedTextStyle, opt, isEmphasis) {\n\t  setTextStyleCommon(textStyle, textStyleModel, opt, isEmphasis);\n\t  specifiedTextStyle && zrUtil.extend(textStyle, specifiedTextStyle);\n\t  textStyle.host && textStyle.host.dirty && textStyle.host.dirty(false);\n\t  return textStyle;\n\t}\n\t/**\n\t * Set text option in the style.\n\t * @deprecated\n\t * @param {Object} textStyle\n\t * @param {module:echarts/model/Model} labelModel\n\t * @param {string|boolean} defaultColor Default text color.\n\t *        If set as false, it will be processed as a emphasis style.\n\t */\n\t\n\t\n\tfunction setText(textStyle, labelModel, defaultColor) {\n\t  var opt = {\n\t    isRectText: true\n\t  };\n\t  var isEmphasis;\n\t\n\t  if (defaultColor === false) {\n\t    isEmphasis = true;\n\t  } else {\n\t    // Support setting color as 'auto' to get visual color.\n\t    opt.autoColor = defaultColor;\n\t  }\n\t\n\t  setTextStyleCommon(textStyle, labelModel, opt, isEmphasis);\n\t  textStyle.host && textStyle.host.dirty && textStyle.host.dirty(false);\n\t}\n\t/**\n\t * {\n\t *      disableBox: boolean, Whether diable drawing box of block (outer most).\n\t *      isRectText: boolean,\n\t *      autoColor: string, specify a color when color is 'auto',\n\t *              for textFill, textStroke, textBackgroundColor, and textBorderColor.\n\t *              If autoColor specified, it is used as default textFill.\n\t *      useInsideStyle:\n\t *              `true`: Use inside style (textFill, textStroke, textStrokeWidth)\n\t *                  if `textFill` is not specified.\n\t *              `false`: Do not use inside style.\n\t *              `null/undefined`: use inside style if `isRectText` is true and\n\t *                  `textFill` is not specified and textPosition contains `'inside'`.\n\t *      forceRich: boolean\n\t * }\n\t */\n\t\n\t\n\tfunction setTextStyleCommon(textStyle, textStyleModel, opt, isEmphasis) {\n\t  // Consider there will be abnormal when merge hover style to normal style if given default value.\n\t  opt = opt || EMPTY_OBJ;\n\t\n\t  if (opt.isRectText) {\n\t    var textPosition = textStyleModel.getShallow('position') || (isEmphasis ? null : 'inside'); // 'outside' is not a valid zr textPostion value, but used\n\t    // in bar series, and magric type should be considered.\n\t\n\t    textPosition === 'outside' && (textPosition = 'top');\n\t    textStyle.textPosition = textPosition;\n\t    textStyle.textOffset = textStyleModel.getShallow('offset');\n\t    var labelRotate = textStyleModel.getShallow('rotate');\n\t    labelRotate != null && (labelRotate *= Math.PI / 180);\n\t    textStyle.textRotation = labelRotate;\n\t    textStyle.textDistance = zrUtil.retrieve2(textStyleModel.getShallow('distance'), isEmphasis ? null : 5);\n\t  }\n\t\n\t  var ecModel = textStyleModel.ecModel;\n\t  var globalTextStyle = ecModel && ecModel.option.textStyle; // Consider case:\n\t  // {\n\t  //     data: [{\n\t  //         value: 12,\n\t  //         label: {\n\t  //             rich: {\n\t  //                 // no 'a' here but using parent 'a'.\n\t  //             }\n\t  //         }\n\t  //     }],\n\t  //     rich: {\n\t  //         a: { ... }\n\t  //     }\n\t  // }\n\t\n\t  var richItemNames = getRichItemNames(textStyleModel);\n\t  var richResult;\n\t\n\t  if (richItemNames) {\n\t    richResult = {};\n\t\n\t    for (var name in richItemNames) {\n\t      if (richItemNames.hasOwnProperty(name)) {\n\t        // Cascade is supported in rich.\n\t        var richTextStyle = textStyleModel.getModel(['rich', name]); // In rich, never `disableBox`.\n\t\n\t        setTokenTextStyle(richResult[name] = {}, richTextStyle, globalTextStyle, opt, isEmphasis);\n\t      }\n\t    }\n\t  }\n\t\n\t  textStyle.rich = richResult;\n\t  setTokenTextStyle(textStyle, textStyleModel, globalTextStyle, opt, isEmphasis, true);\n\t\n\t  if (opt.forceRich && !opt.textStyle) {\n\t    opt.textStyle = {};\n\t  }\n\t\n\t  return textStyle;\n\t} // Consider case:\n\t// {\n\t//     data: [{\n\t//         value: 12,\n\t//         label: {\n\t//             rich: {\n\t//                 // no 'a' here but using parent 'a'.\n\t//             }\n\t//         }\n\t//     }],\n\t//     rich: {\n\t//         a: { ... }\n\t//     }\n\t// }\n\t\n\t\n\tfunction getRichItemNames(textStyleModel) {\n\t  // Use object to remove duplicated names.\n\t  var richItemNameMap;\n\t\n\t  while (textStyleModel && textStyleModel !== textStyleModel.ecModel) {\n\t    var rich = (textStyleModel.option || EMPTY_OBJ).rich;\n\t\n\t    if (rich) {\n\t      richItemNameMap = richItemNameMap || {};\n\t\n\t      for (var name in rich) {\n\t        if (rich.hasOwnProperty(name)) {\n\t          richItemNameMap[name] = 1;\n\t        }\n\t      }\n\t    }\n\t\n\t    textStyleModel = textStyleModel.parentModel;\n\t  }\n\t\n\t  return richItemNameMap;\n\t}\n\t\n\tfunction setTokenTextStyle(textStyle, textStyleModel, globalTextStyle, opt, isEmphasis, isBlock) {\n\t  // In merge mode, default value should not be given.\n\t  globalTextStyle = !isEmphasis && globalTextStyle || EMPTY_OBJ;\n\t  textStyle.textFill = getAutoColor(textStyleModel.getShallow('color'), opt) || globalTextStyle.color;\n\t  textStyle.textStroke = getAutoColor(textStyleModel.getShallow('textBorderColor'), opt) || globalTextStyle.textBorderColor;\n\t  textStyle.textStrokeWidth = zrUtil.retrieve2(textStyleModel.getShallow('textBorderWidth'), globalTextStyle.textBorderWidth);\n\t\n\t  if (!isEmphasis) {\n\t    if (isBlock) {\n\t      // Always set `insideRollback`, for clearing previous.\n\t      var originalTextPosition = textStyle.textPosition;\n\t      textStyle.insideRollback = applyInsideStyle(textStyle, originalTextPosition, opt); // Save original textPosition, because style.textPosition will be repalced by\n\t      // real location (like [10, 30]) in zrender.\n\t\n\t      textStyle.insideOriginalTextPosition = originalTextPosition;\n\t      textStyle.insideRollbackOpt = opt;\n\t    } // Set default finally.\n\t\n\t\n\t    if (textStyle.textFill == null) {\n\t      textStyle.textFill = opt.autoColor;\n\t    }\n\t  } // Do not use `getFont` here, because merge should be supported, where\n\t  // part of these properties may be changed in emphasis style, and the\n\t  // others should remain their original value got from normal style.\n\t\n\t\n\t  textStyle.fontStyle = textStyleModel.getShallow('fontStyle') || globalTextStyle.fontStyle;\n\t  textStyle.fontWeight = textStyleModel.getShallow('fontWeight') || globalTextStyle.fontWeight;\n\t  textStyle.fontSize = textStyleModel.getShallow('fontSize') || globalTextStyle.fontSize;\n\t  textStyle.fontFamily = textStyleModel.getShallow('fontFamily') || globalTextStyle.fontFamily;\n\t  textStyle.textAlign = textStyleModel.getShallow('align');\n\t  textStyle.textVerticalAlign = textStyleModel.getShallow('verticalAlign') || textStyleModel.getShallow('baseline');\n\t  textStyle.textLineHeight = textStyleModel.getShallow('lineHeight');\n\t  textStyle.textWidth = textStyleModel.getShallow('width');\n\t  textStyle.textHeight = textStyleModel.getShallow('height');\n\t  textStyle.textTag = textStyleModel.getShallow('tag');\n\t\n\t  if (!isBlock || !opt.disableBox) {\n\t    textStyle.textBackgroundColor = getAutoColor(textStyleModel.getShallow('backgroundColor'), opt);\n\t    textStyle.textPadding = textStyleModel.getShallow('padding');\n\t    textStyle.textBorderColor = getAutoColor(textStyleModel.getShallow('borderColor'), opt);\n\t    textStyle.textBorderWidth = textStyleModel.getShallow('borderWidth');\n\t    textStyle.textBorderRadius = textStyleModel.getShallow('borderRadius');\n\t    textStyle.textBoxShadowColor = textStyleModel.getShallow('shadowColor');\n\t    textStyle.textBoxShadowBlur = textStyleModel.getShallow('shadowBlur');\n\t    textStyle.textBoxShadowOffsetX = textStyleModel.getShallow('shadowOffsetX');\n\t    textStyle.textBoxShadowOffsetY = textStyleModel.getShallow('shadowOffsetY');\n\t  }\n\t\n\t  textStyle.textShadowColor = textStyleModel.getShallow('textShadowColor') || globalTextStyle.textShadowColor;\n\t  textStyle.textShadowBlur = textStyleModel.getShallow('textShadowBlur') || globalTextStyle.textShadowBlur;\n\t  textStyle.textShadowOffsetX = textStyleModel.getShallow('textShadowOffsetX') || globalTextStyle.textShadowOffsetX;\n\t  textStyle.textShadowOffsetY = textStyleModel.getShallow('textShadowOffsetY') || globalTextStyle.textShadowOffsetY;\n\t}\n\t\n\tfunction getAutoColor(color, opt) {\n\t  return color !== 'auto' ? color : opt && opt.autoColor ? opt.autoColor : null;\n\t}\n\t\n\tfunction applyInsideStyle(textStyle, textPosition, opt) {\n\t  var useInsideStyle = opt.useInsideStyle;\n\t  var insideRollback;\n\t\n\t  if (textStyle.textFill == null && useInsideStyle !== false && (useInsideStyle === true || opt.isRectText && textPosition // textPosition can be [10, 30]\n\t  && typeof textPosition === 'string' && textPosition.indexOf('inside') >= 0)) {\n\t    insideRollback = {\n\t      textFill: null,\n\t      textStroke: textStyle.textStroke,\n\t      textStrokeWidth: textStyle.textStrokeWidth\n\t    };\n\t    textStyle.textFill = '#fff'; // Consider text with #fff overflow its container.\n\t\n\t    if (textStyle.textStroke == null) {\n\t      textStyle.textStroke = opt.autoColor;\n\t      textStyle.textStrokeWidth == null && (textStyle.textStrokeWidth = 2);\n\t    }\n\t  }\n\t\n\t  return insideRollback;\n\t}\n\t\n\tfunction rollbackInsideStyle(style) {\n\t  var insideRollback = style.insideRollback;\n\t\n\t  if (insideRollback) {\n\t    style.textFill = insideRollback.textFill;\n\t    style.textStroke = insideRollback.textStroke;\n\t    style.textStrokeWidth = insideRollback.textStrokeWidth;\n\t  }\n\t}\n\t\n\tfunction getFont(opt, ecModel) {\n\t  // ecModel or default text style model.\n\t  var gTextStyleModel = ecModel || ecModel.getModel('textStyle');\n\t  return zrUtil.trim([// FIXME in node-canvas fontWeight is before fontStyle\n\t  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\t}\n\t\n\tfunction animateOrSetProps(isUpdate, el, props, animatableModel, dataIndex, cb) {\n\t  if (typeof dataIndex === 'function') {\n\t    cb = dataIndex;\n\t    dataIndex = null;\n\t  } // Do not check 'animation' property directly here. Consider this case:\n\t  // animation model is an `itemModel`, whose does not have `isAnimationEnabled`\n\t  // but its parent model (`seriesModel`) does.\n\t\n\t\n\t  var animationEnabled = animatableModel && animatableModel.isAnimationEnabled();\n\t\n\t  if (animationEnabled) {\n\t    var postfix = isUpdate ? 'Update' : '';\n\t    var duration = animatableModel.getShallow('animationDuration' + postfix);\n\t    var animationEasing = animatableModel.getShallow('animationEasing' + postfix);\n\t    var animationDelay = animatableModel.getShallow('animationDelay' + postfix);\n\t\n\t    if (typeof animationDelay === 'function') {\n\t      animationDelay = animationDelay(dataIndex, animatableModel.getAnimationDelayParams ? animatableModel.getAnimationDelayParams(el, dataIndex) : null);\n\t    }\n\t\n\t    if (typeof duration === 'function') {\n\t      duration = duration(dataIndex);\n\t    }\n\t\n\t    duration > 0 ? el.animateTo(props, duration, animationDelay || 0, animationEasing, cb, !!cb) : (el.stopAnimation(), el.attr(props), cb && cb());\n\t  } else {\n\t    el.stopAnimation();\n\t    el.attr(props);\n\t    cb && cb();\n\t  }\n\t}\n\t/**\n\t * Update graphic element properties with or without animation according to the\n\t * configuration in series.\n\t *\n\t * Caution: this method will stop previous animation.\n\t * So if do not use this method to one element twice before\n\t * animation starts, unless you know what you are doing.\n\t *\n\t * @param {module:zrender/Element} el\n\t * @param {Object} props\n\t * @param {module:echarts/model/Model} [animatableModel]\n\t * @param {number} [dataIndex]\n\t * @param {Function} [cb]\n\t * @example\n\t *     graphic.updateProps(el, {\n\t *         position: [100, 100]\n\t *     }, seriesModel, dataIndex, function () { console.log('Animation done!'); });\n\t *     // Or\n\t *     graphic.updateProps(el, {\n\t *         position: [100, 100]\n\t *     }, seriesModel, function () { console.log('Animation done!'); });\n\t */\n\t\n\t\n\tfunction updateProps(el, props, animatableModel, dataIndex, cb) {\n\t  animateOrSetProps(true, el, props, animatableModel, dataIndex, cb);\n\t}\n\t/**\n\t * Init graphic element properties with or without animation according to the\n\t * configuration in series.\n\t *\n\t * Caution: this method will stop previous animation.\n\t * So if do not use this method to one element twice before\n\t * animation starts, unless you know what you are doing.\n\t *\n\t * @param {module:zrender/Element} el\n\t * @param {Object} props\n\t * @param {module:echarts/model/Model} [animatableModel]\n\t * @param {number} [dataIndex]\n\t * @param {Function} cb\n\t */\n\t\n\t\n\tfunction initProps(el, props, animatableModel, dataIndex, cb) {\n\t  animateOrSetProps(false, el, props, animatableModel, dataIndex, cb);\n\t}\n\t/**\n\t * Get transform matrix of target (param target),\n\t * in coordinate of its ancestor (param ancestor)\n\t *\n\t * @param {module:zrender/mixin/Transformable} target\n\t * @param {module:zrender/mixin/Transformable} [ancestor]\n\t */\n\t\n\t\n\tfunction getTransform(target, ancestor) {\n\t  var mat = matrix.identity([]);\n\t\n\t  while (target && target !== ancestor) {\n\t    matrix.mul(mat, target.getLocalTransform(), mat);\n\t    target = target.parent;\n\t  }\n\t\n\t  return mat;\n\t}\n\t/**\n\t * Apply transform to an vertex.\n\t * @param {Array.<number>} target [x, y]\n\t * @param {Array.<number>|TypedArray.<number>|Object} transform Can be:\n\t *      + Transform matrix: like [1, 0, 0, 1, 0, 0]\n\t *      + {position, rotation, scale}, the same as `zrender/Transformable`.\n\t * @param {boolean=} invert Whether use invert matrix.\n\t * @return {Array.<number>} [x, y]\n\t */\n\t\n\t\n\tfunction applyTransform(target, transform, invert) {\n\t  if (transform && !zrUtil.isArrayLike(transform)) {\n\t    transform = Transformable.getLocalTransform(transform);\n\t  }\n\t\n\t  if (invert) {\n\t    transform = matrix.invert([], transform);\n\t  }\n\t\n\t  return vector.applyTransform([], target, transform);\n\t}\n\t/**\n\t * @param {string} direction 'left' 'right' 'top' 'bottom'\n\t * @param {Array.<number>} transform Transform matrix: like [1, 0, 0, 1, 0, 0]\n\t * @param {boolean=} invert Whether use invert matrix.\n\t * @return {string} Transformed direction. 'left' 'right' 'top' 'bottom'\n\t */\n\t\n\t\n\tfunction transformDirection(direction, transform, invert) {\n\t  // Pick a base, ensure that transform result will not be (0, 0).\n\t  var hBase = transform[4] === 0 || transform[5] === 0 || transform[0] === 0 ? 1 : Math.abs(2 * transform[4] / transform[0]);\n\t  var vBase = transform[4] === 0 || transform[5] === 0 || transform[2] === 0 ? 1 : Math.abs(2 * transform[4] / transform[2]);\n\t  var vertex = [direction === 'left' ? -hBase : direction === 'right' ? hBase : 0, direction === 'top' ? -vBase : direction === 'bottom' ? vBase : 0];\n\t  vertex = applyTransform(vertex, transform, invert);\n\t  return Math.abs(vertex[0]) > Math.abs(vertex[1]) ? vertex[0] > 0 ? 'right' : 'left' : vertex[1] > 0 ? 'bottom' : 'top';\n\t}\n\t/**\n\t * Apply group transition animation from g1 to g2.\n\t * If no animatableModel, no animation.\n\t */\n\t\n\t\n\tfunction groupTransition(g1, g2, animatableModel, cb) {\n\t  if (!g1 || !g2) {\n\t    return;\n\t  }\n\t\n\t  function getElMap(g) {\n\t    var elMap = {};\n\t    g.traverse(function (el) {\n\t      if (!el.isGroup && el.anid) {\n\t        elMap[el.anid] = el;\n\t      }\n\t    });\n\t    return elMap;\n\t  }\n\t\n\t  function getAnimatableProps(el) {\n\t    var obj = {\n\t      position: vector.clone(el.position),\n\t      rotation: el.rotation\n\t    };\n\t\n\t    if (el.shape) {\n\t      obj.shape = zrUtil.extend({}, el.shape);\n\t    }\n\t\n\t    return obj;\n\t  }\n\t\n\t  var elMap1 = getElMap(g1);\n\t  g2.traverse(function (el) {\n\t    if (!el.isGroup && el.anid) {\n\t      var oldEl = elMap1[el.anid];\n\t\n\t      if (oldEl) {\n\t        var newProp = getAnimatableProps(el);\n\t        el.attr(getAnimatableProps(oldEl));\n\t        updateProps(el, newProp, animatableModel, el.dataIndex);\n\t      } // else {\n\t      //     if (el.previousProps) {\n\t      //         graphic.updateProps\n\t      //     }\n\t      // }\n\t\n\t    }\n\t  });\n\t}\n\t/**\n\t * @param {Array.<Array.<number>>} points Like: [[23, 44], [53, 66], ...]\n\t * @param {Object} rect {x, y, width, height}\n\t * @return {Array.<Array.<number>>} A new clipped points.\n\t */\n\t\n\t\n\tfunction clipPointsByRect(points, rect) {\n\t  return zrUtil.map(points, function (point) {\n\t    var x = point[0];\n\t    x = mathMax(x, rect.x);\n\t    x = mathMin(x, rect.x + rect.width);\n\t    var y = point[1];\n\t    y = mathMax(y, rect.y);\n\t    y = mathMin(y, rect.y + rect.height);\n\t    return [x, y];\n\t  });\n\t}\n\t/**\n\t * @param {Object} targetRect {x, y, width, height}\n\t * @param {Object} rect {x, y, width, height}\n\t * @return {Object} A new clipped rect. If rect size are negative, return undefined.\n\t */\n\t\n\t\n\tfunction clipRectByRect(targetRect, rect) {\n\t  var x = mathMax(targetRect.x, rect.x);\n\t  var x2 = mathMin(targetRect.x + targetRect.width, rect.x + rect.width);\n\t  var y = mathMax(targetRect.y, rect.y);\n\t  var y2 = mathMin(targetRect.y + targetRect.height, rect.y + rect.height);\n\t\n\t  if (x2 >= x && y2 >= y) {\n\t    return {\n\t      x: x,\n\t      y: y,\n\t      width: x2 - x,\n\t      height: y2 - y\n\t    };\n\t  }\n\t}\n\t/**\n\t * @param {string} iconStr Support 'image://' or 'path://' or direct svg path.\n\t * @param {Object} [opt] Properties of `module:zrender/Element`, except `style`.\n\t * @param {Object} [rect] {x, y, width, height}\n\t * @return {module:zrender/Element} Icon path or image element.\n\t */\n\t\n\t\n\tfunction createIcon(iconStr, opt, rect) {\n\t  opt = zrUtil.extend({\n\t    rectHover: true\n\t  }, opt);\n\t  var style = opt.style = {\n\t    strokeNoScale: true\n\t  };\n\t  rect = rect || {\n\t    x: -1,\n\t    y: -1,\n\t    width: 2,\n\t    height: 2\n\t  };\n\t\n\t  if (iconStr) {\n\t    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\t  }\n\t}\n\t\n\texports.extendShape = extendShape;\n\texports.extendPath = extendPath;\n\texports.makePath = makePath;\n\texports.makeImage = makeImage;\n\texports.mergePath = mergePath;\n\texports.resizePath = resizePath;\n\texports.subPixelOptimizeLine = subPixelOptimizeLine;\n\texports.subPixelOptimizeRect = subPixelOptimizeRect;\n\texports.subPixelOptimize = subPixelOptimize;\n\texports.setHoverStyle = setHoverStyle;\n\texports.setLabelStyle = setLabelStyle;\n\texports.setTextStyle = setTextStyle;\n\texports.setText = setText;\n\texports.getFont = getFont;\n\texports.updateProps = updateProps;\n\texports.initProps = initProps;\n\texports.getTransform = getTransform;\n\texports.applyTransform = applyTransform;\n\texports.transformDirection = transformDirection;\n\texports.groupTransition = groupTransition;\n\texports.clipPointsByRect = clipPointsByRect;\n\texports.clipRectByRect = clipRectByRect;\n\texports.createIcon = createIcon;\n\n/***/ },\n/* 33 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar zrUtil = __webpack_require__(1);\n\t\n\tvar graphic = __webpack_require__(32);\n\t\n\tvar BoundingRect = __webpack_require__(4);\n\t\n\t// Symbol factory\n\t\n\t/**\n\t * Triangle shape\n\t * @inner\n\t */\n\tvar Triangle = graphic.extendShape({\n\t  type: 'triangle',\n\t  shape: {\n\t    cx: 0,\n\t    cy: 0,\n\t    width: 0,\n\t    height: 0\n\t  },\n\t  buildPath: function (path, shape) {\n\t    var cx = shape.cx;\n\t    var cy = shape.cy;\n\t    var width = shape.width / 2;\n\t    var height = shape.height / 2;\n\t    path.moveTo(cx, cy - height);\n\t    path.lineTo(cx + width, cy + height);\n\t    path.lineTo(cx - width, cy + height);\n\t    path.closePath();\n\t  }\n\t});\n\t/**\n\t * Diamond shape\n\t * @inner\n\t */\n\t\n\tvar Diamond = graphic.extendShape({\n\t  type: 'diamond',\n\t  shape: {\n\t    cx: 0,\n\t    cy: 0,\n\t    width: 0,\n\t    height: 0\n\t  },\n\t  buildPath: function (path, shape) {\n\t    var cx = shape.cx;\n\t    var cy = shape.cy;\n\t    var width = shape.width / 2;\n\t    var height = shape.height / 2;\n\t    path.moveTo(cx, cy - height);\n\t    path.lineTo(cx + width, cy);\n\t    path.lineTo(cx, cy + height);\n\t    path.lineTo(cx - width, cy);\n\t    path.closePath();\n\t  }\n\t});\n\t/**\n\t * Pin shape\n\t * @inner\n\t */\n\t\n\tvar Pin = graphic.extendShape({\n\t  type: 'pin',\n\t  shape: {\n\t    // x, y on the cusp\n\t    x: 0,\n\t    y: 0,\n\t    width: 0,\n\t    height: 0\n\t  },\n\t  buildPath: function (path, shape) {\n\t    var x = shape.x;\n\t    var y = shape.y;\n\t    var w = shape.width / 5 * 3; // Height must be larger than width\n\t\n\t    var h = Math.max(w, shape.height);\n\t    var r = w / 2; // Dist on y with tangent point and circle center\n\t\n\t    var dy = r * r / (h - r);\n\t    var cy = y - h + r + dy;\n\t    var angle = Math.asin(dy / r); // Dist on x with tangent point and circle center\n\t\n\t    var dx = Math.cos(angle) * r;\n\t    var tanX = Math.sin(angle);\n\t    var tanY = Math.cos(angle);\n\t    var cpLen = r * 0.6;\n\t    var cpLen2 = r * 0.7;\n\t    path.moveTo(x - dx, cy + dy);\n\t    path.arc(x, cy, r, Math.PI - angle, Math.PI * 2 + angle);\n\t    path.bezierCurveTo(x + dx - tanX * cpLen, cy + dy + tanY * cpLen, x, y - cpLen2, x, y);\n\t    path.bezierCurveTo(x, y - cpLen2, x - dx + tanX * cpLen, cy + dy + tanY * cpLen, x - dx, cy + dy);\n\t    path.closePath();\n\t  }\n\t});\n\t/**\n\t * Arrow shape\n\t * @inner\n\t */\n\t\n\tvar Arrow = graphic.extendShape({\n\t  type: 'arrow',\n\t  shape: {\n\t    x: 0,\n\t    y: 0,\n\t    width: 0,\n\t    height: 0\n\t  },\n\t  buildPath: function (ctx, shape) {\n\t    var height = shape.height;\n\t    var width = shape.width;\n\t    var x = shape.x;\n\t    var y = shape.y;\n\t    var dx = width / 3 * 2;\n\t    ctx.moveTo(x, y);\n\t    ctx.lineTo(x + dx, y + height);\n\t    ctx.lineTo(x, y + height / 4 * 3);\n\t    ctx.lineTo(x - dx, y + height);\n\t    ctx.lineTo(x, y);\n\t    ctx.closePath();\n\t  }\n\t});\n\t/**\n\t * Map of path contructors\n\t * @type {Object.<string, module:zrender/graphic/Path>}\n\t */\n\t\n\tvar symbolCtors = {\n\t  line: graphic.Line,\n\t  rect: graphic.Rect,\n\t  roundRect: graphic.Rect,\n\t  square: graphic.Rect,\n\t  circle: graphic.Circle,\n\t  diamond: Diamond,\n\t  pin: Pin,\n\t  arrow: Arrow,\n\t  triangle: Triangle\n\t};\n\tvar symbolShapeMakers = {\n\t  line: function (x, y, w, h, shape) {\n\t    // FIXME\n\t    shape.x1 = x;\n\t    shape.y1 = y + h / 2;\n\t    shape.x2 = x + w;\n\t    shape.y2 = y + h / 2;\n\t  },\n\t  rect: function (x, y, w, h, shape) {\n\t    shape.x = x;\n\t    shape.y = y;\n\t    shape.width = w;\n\t    shape.height = h;\n\t  },\n\t  roundRect: function (x, y, w, h, shape) {\n\t    shape.x = x;\n\t    shape.y = y;\n\t    shape.width = w;\n\t    shape.height = h;\n\t    shape.r = Math.min(w, h) / 4;\n\t  },\n\t  square: function (x, y, w, h, shape) {\n\t    var size = Math.min(w, h);\n\t    shape.x = x;\n\t    shape.y = y;\n\t    shape.width = size;\n\t    shape.height = size;\n\t  },\n\t  circle: function (x, y, w, h, shape) {\n\t    // Put circle in the center of square\n\t    shape.cx = x + w / 2;\n\t    shape.cy = y + h / 2;\n\t    shape.r = Math.min(w, h) / 2;\n\t  },\n\t  diamond: function (x, y, w, h, shape) {\n\t    shape.cx = x + w / 2;\n\t    shape.cy = y + h / 2;\n\t    shape.width = w;\n\t    shape.height = h;\n\t  },\n\t  pin: function (x, y, w, h, shape) {\n\t    shape.x = x + w / 2;\n\t    shape.y = y + h / 2;\n\t    shape.width = w;\n\t    shape.height = h;\n\t  },\n\t  arrow: function (x, y, w, h, shape) {\n\t    shape.x = x + w / 2;\n\t    shape.y = y + h / 2;\n\t    shape.width = w;\n\t    shape.height = h;\n\t  },\n\t  triangle: function (x, y, w, h, shape) {\n\t    shape.cx = x + w / 2;\n\t    shape.cy = y + h / 2;\n\t    shape.width = w;\n\t    shape.height = h;\n\t  }\n\t};\n\tvar symbolBuildProxies = {};\n\tzrUtil.each(symbolCtors, function (Ctor, name) {\n\t  symbolBuildProxies[name] = new Ctor();\n\t});\n\tvar SymbolClz = graphic.extendShape({\n\t  type: 'symbol',\n\t  shape: {\n\t    symbolType: '',\n\t    x: 0,\n\t    y: 0,\n\t    width: 0,\n\t    height: 0\n\t  },\n\t  beforeBrush: function () {\n\t    var style = this.style;\n\t    var shape = this.shape; // FIXME\n\t\n\t    if (shape.symbolType === 'pin' && style.textPosition === 'inside') {\n\t      style.textPosition = ['50%', '40%'];\n\t      style.textAlign = 'center';\n\t      style.textVerticalAlign = 'middle';\n\t    }\n\t  },\n\t  buildPath: function (ctx, shape, inBundle) {\n\t    var symbolType = shape.symbolType;\n\t    var proxySymbol = symbolBuildProxies[symbolType];\n\t\n\t    if (shape.symbolType !== 'none') {\n\t      if (!proxySymbol) {\n\t        // Default rect\n\t        symbolType = 'rect';\n\t        proxySymbol = symbolBuildProxies[symbolType];\n\t      }\n\t\n\t      symbolShapeMakers[symbolType](shape.x, shape.y, shape.width, shape.height, proxySymbol.shape);\n\t      proxySymbol.buildPath(ctx, proxySymbol.shape, inBundle);\n\t    }\n\t  }\n\t}); // Provide setColor helper method to avoid determine if set the fill or stroke outside\n\t\n\tfunction symbolPathSetColor(color, innerColor) {\n\t  if (this.type !== 'image') {\n\t    var symbolStyle = this.style;\n\t    var symbolShape = this.shape;\n\t\n\t    if (symbolShape && symbolShape.symbolType === 'line') {\n\t      symbolStyle.stroke = color;\n\t    } else if (this.__isEmptyBrush) {\n\t      symbolStyle.stroke = color;\n\t      symbolStyle.fill = innerColor || '#fff';\n\t    } else {\n\t      // FIXME 判断图形默认是填充还是描边，使用 onlyStroke ?\n\t      symbolStyle.fill && (symbolStyle.fill = color);\n\t      symbolStyle.stroke && (symbolStyle.stroke = color);\n\t    }\n\t\n\t    this.dirty(false);\n\t  }\n\t}\n\t/**\n\t * Create a symbol element with given symbol configuration: shape, x, y, width, height, color\n\t * @param {string} symbolType\n\t * @param {number} x\n\t * @param {number} y\n\t * @param {number} w\n\t * @param {number} h\n\t * @param {string} color\n\t * @param {boolean} [keepAspect=false] whether to keep the ratio of w/h,\n\t *                            for path and image only.\n\t */\n\t\n\t\n\tfunction createSymbol(symbolType, x, y, w, h, color, keepAspect) {\n\t  // TODO Support image object, DynamicImage.\n\t  var isEmpty = symbolType.indexOf('empty') === 0;\n\t\n\t  if (isEmpty) {\n\t    symbolType = symbolType.substr(5, 1).toLowerCase() + symbolType.substr(6);\n\t  }\n\t\n\t  var symbolPath;\n\t\n\t  if (symbolType.indexOf('image://') === 0) {\n\t    symbolPath = graphic.makeImage(symbolType.slice(8), new BoundingRect(x, y, w, h), keepAspect ? 'center' : 'cover');\n\t  } else if (symbolType.indexOf('path://') === 0) {\n\t    symbolPath = graphic.makePath(symbolType.slice(7), {}, new BoundingRect(x, y, w, h), keepAspect ? 'center' : 'cover');\n\t  } else {\n\t    symbolPath = new SymbolClz({\n\t      shape: {\n\t        symbolType: symbolType,\n\t        x: x,\n\t        y: y,\n\t        width: w,\n\t        height: h\n\t      }\n\t    });\n\t  }\n\t\n\t  symbolPath.__isEmptyBrush = isEmpty;\n\t  symbolPath.setColor = symbolPathSetColor;\n\t  symbolPath.setColor(color);\n\t  return symbolPath;\n\t}\n\t\n\texports.createSymbol = createSymbol;\n\n/***/ },\n/* 34 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar _util = __webpack_require__(1);\n\t\n\tvar createHashMap = _util.createHashMap;\n\t\n\t// Pick color from palette for each data item.\n\t// Applicable for charts that require applying color palette\n\t// in data level (like pie, funnel, chord).\n\tfunction _default(seriesType) {\n\t  return {\n\t    getTargetSeries: function (ecModel) {\n\t      // Pie and funnel may use diferrent scope\n\t      var paletteScope = {};\n\t      var seiresModelMap = createHashMap();\n\t      ecModel.eachSeriesByType(seriesType, function (seriesModel) {\n\t        seriesModel.__paletteScope = paletteScope;\n\t        seiresModelMap.set(seriesModel.uid, seriesModel);\n\t      });\n\t      return seiresModelMap;\n\t    },\n\t    reset: function (seriesModel, ecModel) {\n\t      var dataAll = seriesModel.getRawData();\n\t      var idxMap = {};\n\t      var data = seriesModel.getData();\n\t      data.each(function (idx) {\n\t        var rawIdx = data.getRawIndex(idx);\n\t        idxMap[rawIdx] = idx;\n\t      });\n\t      dataAll.each(function (rawIdx) {\n\t        var filteredIdx = idxMap[rawIdx]; // If series.itemStyle.normal.color is a function. itemVisual may be encoded\n\t\n\t        var singleDataColor = filteredIdx != null && data.getItemVisual(filteredIdx, 'color', true);\n\t\n\t        if (!singleDataColor) {\n\t          // FIXME Performance\n\t          var itemModel = dataAll.getItemModel(rawIdx);\n\t          var color = itemModel.get('itemStyle.color') || seriesModel.getColorFromPalette(dataAll.getName(rawIdx), seriesModel.__paletteScope, dataAll.count()); // Legend may use the visual info in data before processed\n\t\n\t          dataAll.setItemVisual(rawIdx, 'color', color); // Data is not filtered\n\t\n\t          if (filteredIdx != null) {\n\t            data.setItemVisual(filteredIdx, 'color', color);\n\t          }\n\t        } else {\n\t          // Set data all color for legend\n\t          dataAll.setItemVisual(rawIdx, 'color', singleDataColor);\n\t        }\n\t      });\n\t    }\n\t  };\n\t}\n\t\n\tmodule.exports = _default;\n\n/***/ },\n/* 35 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar Clip = __webpack_require__(36);\n\t\n\tvar color = __webpack_require__(26);\n\t\n\tvar _util = __webpack_require__(1);\n\t\n\tvar isArrayLike = _util.isArrayLike;\n\t\n\t/**\n\t * @module echarts/animation/Animator\n\t */\n\tvar arraySlice = Array.prototype.slice;\n\t\n\tfunction defaultGetter(target, key) {\n\t  return target[key];\n\t}\n\t\n\tfunction defaultSetter(target, key, value) {\n\t  target[key] = value;\n\t}\n\t/**\n\t * @param  {number} p0\n\t * @param  {number} p1\n\t * @param  {number} percent\n\t * @return {number}\n\t */\n\t\n\t\n\tfunction interpolateNumber(p0, p1, percent) {\n\t  return (p1 - p0) * percent + p0;\n\t}\n\t/**\n\t * @param  {string} p0\n\t * @param  {string} p1\n\t * @param  {number} percent\n\t * @return {string}\n\t */\n\t\n\t\n\tfunction interpolateString(p0, p1, percent) {\n\t  return percent > 0.5 ? p1 : p0;\n\t}\n\t/**\n\t * @param  {Array} p0\n\t * @param  {Array} p1\n\t * @param  {number} percent\n\t * @param  {Array} out\n\t * @param  {number} arrDim\n\t */\n\t\n\t\n\tfunction interpolateArray(p0, p1, percent, out, arrDim) {\n\t  var len = p0.length;\n\t\n\t  if (arrDim == 1) {\n\t    for (var i = 0; i < len; i++) {\n\t      out[i] = interpolateNumber(p0[i], p1[i], percent);\n\t    }\n\t  } else {\n\t    var len2 = len && p0[0].length;\n\t\n\t    for (var i = 0; i < len; i++) {\n\t      for (var j = 0; j < len2; j++) {\n\t        out[i][j] = interpolateNumber(p0[i][j], p1[i][j], percent);\n\t      }\n\t    }\n\t  }\n\t} // arr0 is source array, arr1 is target array.\n\t// Do some preprocess to avoid error happened when interpolating from arr0 to arr1\n\t\n\t\n\tfunction fillArr(arr0, arr1, arrDim) {\n\t  var arr0Len = arr0.length;\n\t  var arr1Len = arr1.length;\n\t\n\t  if (arr0Len !== arr1Len) {\n\t    // FIXME Not work for TypedArray\n\t    var isPreviousLarger = arr0Len > arr1Len;\n\t\n\t    if (isPreviousLarger) {\n\t      // Cut the previous\n\t      arr0.length = arr1Len;\n\t    } else {\n\t      // Fill the previous\n\t      for (var i = arr0Len; i < arr1Len; i++) {\n\t        arr0.push(arrDim === 1 ? arr1[i] : arraySlice.call(arr1[i]));\n\t      }\n\t    }\n\t  } // Handling NaN value\n\t\n\t\n\t  var len2 = arr0[0] && arr0[0].length;\n\t\n\t  for (var i = 0; i < arr0.length; i++) {\n\t    if (arrDim === 1) {\n\t      if (isNaN(arr0[i])) {\n\t        arr0[i] = arr1[i];\n\t      }\n\t    } else {\n\t      for (var j = 0; j < len2; j++) {\n\t        if (isNaN(arr0[i][j])) {\n\t          arr0[i][j] = arr1[i][j];\n\t        }\n\t      }\n\t    }\n\t  }\n\t}\n\t/**\n\t * @param  {Array} arr0\n\t * @param  {Array} arr1\n\t * @param  {number} arrDim\n\t * @return {boolean}\n\t */\n\t\n\t\n\tfunction isArraySame(arr0, arr1, arrDim) {\n\t  if (arr0 === arr1) {\n\t    return true;\n\t  }\n\t\n\t  var len = arr0.length;\n\t\n\t  if (len !== arr1.length) {\n\t    return false;\n\t  }\n\t\n\t  if (arrDim === 1) {\n\t    for (var i = 0; i < len; i++) {\n\t      if (arr0[i] !== arr1[i]) {\n\t        return false;\n\t      }\n\t    }\n\t  } else {\n\t    var len2 = arr0[0].length;\n\t\n\t    for (var i = 0; i < len; i++) {\n\t      for (var j = 0; j < len2; j++) {\n\t        if (arr0[i][j] !== arr1[i][j]) {\n\t          return false;\n\t        }\n\t      }\n\t    }\n\t  }\n\t\n\t  return true;\n\t}\n\t/**\n\t * Catmull Rom interpolate array\n\t * @param  {Array} p0\n\t * @param  {Array} p1\n\t * @param  {Array} p2\n\t * @param  {Array} p3\n\t * @param  {number} t\n\t * @param  {number} t2\n\t * @param  {number} t3\n\t * @param  {Array} out\n\t * @param  {number} arrDim\n\t */\n\t\n\t\n\tfunction catmullRomInterpolateArray(p0, p1, p2, p3, t, t2, t3, out, arrDim) {\n\t  var len = p0.length;\n\t\n\t  if (arrDim == 1) {\n\t    for (var i = 0; i < len; i++) {\n\t      out[i] = catmullRomInterpolate(p0[i], p1[i], p2[i], p3[i], t, t2, t3);\n\t    }\n\t  } else {\n\t    var len2 = p0[0].length;\n\t\n\t    for (var i = 0; i < len; i++) {\n\t      for (var j = 0; j < len2; j++) {\n\t        out[i][j] = catmullRomInterpolate(p0[i][j], p1[i][j], p2[i][j], p3[i][j], t, t2, t3);\n\t      }\n\t    }\n\t  }\n\t}\n\t/**\n\t * Catmull Rom interpolate number\n\t * @param  {number} p0\n\t * @param  {number} p1\n\t * @param  {number} p2\n\t * @param  {number} p3\n\t * @param  {number} t\n\t * @param  {number} t2\n\t * @param  {number} t3\n\t * @return {number}\n\t */\n\t\n\t\n\tfunction catmullRomInterpolate(p0, p1, p2, p3, t, t2, t3) {\n\t  var v0 = (p2 - p0) * 0.5;\n\t  var v1 = (p3 - p1) * 0.5;\n\t  return (2 * (p1 - p2) + v0 + v1) * t3 + (-3 * (p1 - p2) - 2 * v0 - v1) * t2 + v0 * t + p1;\n\t}\n\t\n\tfunction cloneValue(value) {\n\t  if (isArrayLike(value)) {\n\t    var len = value.length;\n\t\n\t    if (isArrayLike(value[0])) {\n\t      var ret = [];\n\t\n\t      for (var i = 0; i < len; i++) {\n\t        ret.push(arraySlice.call(value[i]));\n\t      }\n\t\n\t      return ret;\n\t    }\n\t\n\t    return arraySlice.call(value);\n\t  }\n\t\n\t  return value;\n\t}\n\t\n\tfunction rgba2String(rgba) {\n\t  rgba[0] = Math.floor(rgba[0]);\n\t  rgba[1] = Math.floor(rgba[1]);\n\t  rgba[2] = Math.floor(rgba[2]);\n\t  return 'rgba(' + rgba.join(',') + ')';\n\t}\n\t\n\tfunction getArrayDim(keyframes) {\n\t  var lastValue = keyframes[keyframes.length - 1].value;\n\t  return isArrayLike(lastValue && lastValue[0]) ? 2 : 1;\n\t}\n\t\n\tfunction createTrackClip(animator, easing, oneTrackDone, keyframes, propName, forceAnimate) {\n\t  var getter = animator._getter;\n\t  var setter = animator._setter;\n\t  var useSpline = easing === 'spline';\n\t  var trackLen = keyframes.length;\n\t\n\t  if (!trackLen) {\n\t    return;\n\t  } // Guess data type\n\t\n\t\n\t  var firstVal = keyframes[0].value;\n\t  var isValueArray = isArrayLike(firstVal);\n\t  var isValueColor = false;\n\t  var isValueString = false; // For vertices morphing\n\t\n\t  var arrDim = isValueArray ? getArrayDim(keyframes) : 0;\n\t  var trackMaxTime; // Sort keyframe as ascending\n\t\n\t  keyframes.sort(function (a, b) {\n\t    return a.time - b.time;\n\t  });\n\t  trackMaxTime = keyframes[trackLen - 1].time; // Percents of each keyframe\n\t\n\t  var kfPercents = []; // Value of each keyframe\n\t\n\t  var kfValues = [];\n\t  var prevValue = keyframes[0].value;\n\t  var isAllValueEqual = true;\n\t\n\t  for (var i = 0; i < trackLen; i++) {\n\t    kfPercents.push(keyframes[i].time / trackMaxTime); // Assume value is a color when it is a string\n\t\n\t    var value = keyframes[i].value; // Check if value is equal, deep check if value is array\n\t\n\t    if (!(isValueArray && isArraySame(value, prevValue, arrDim) || !isValueArray && value === prevValue)) {\n\t      isAllValueEqual = false;\n\t    }\n\t\n\t    prevValue = value; // Try converting a string to a color array\n\t\n\t    if (typeof value == 'string') {\n\t      var colorArray = color.parse(value);\n\t\n\t      if (colorArray) {\n\t        value = colorArray;\n\t        isValueColor = true;\n\t      } else {\n\t        isValueString = true;\n\t      }\n\t    }\n\t\n\t    kfValues.push(value);\n\t  }\n\t\n\t  if (!forceAnimate && isAllValueEqual) {\n\t    return;\n\t  }\n\t\n\t  var lastValue = kfValues[trackLen - 1]; // Polyfill array and NaN value\n\t\n\t  for (var i = 0; i < trackLen - 1; i++) {\n\t    if (isValueArray) {\n\t      fillArr(kfValues[i], lastValue, arrDim);\n\t    } else {\n\t      if (isNaN(kfValues[i]) && !isNaN(lastValue) && !isValueString && !isValueColor) {\n\t        kfValues[i] = lastValue;\n\t      }\n\t    }\n\t  }\n\t\n\t  isValueArray && fillArr(getter(animator._target, propName), lastValue, arrDim); // Cache the key of last frame to speed up when\n\t  // animation playback is sequency\n\t\n\t  var lastFrame = 0;\n\t  var lastFramePercent = 0;\n\t  var start;\n\t  var w;\n\t  var p0;\n\t  var p1;\n\t  var p2;\n\t  var p3;\n\t\n\t  if (isValueColor) {\n\t    var rgba = [0, 0, 0, 0];\n\t  }\n\t\n\t  var onframe = function (target, percent) {\n\t    // Find the range keyframes\n\t    // kf1-----kf2---------current--------kf3\n\t    // find kf2 and kf3 and do interpolation\n\t    var frame; // In the easing function like elasticOut, percent may less than 0\n\t\n\t    if (percent < 0) {\n\t      frame = 0;\n\t    } else if (percent < lastFramePercent) {\n\t      // Start from next key\n\t      // PENDING start from lastFrame ?\n\t      start = Math.min(lastFrame + 1, trackLen - 1);\n\t\n\t      for (frame = start; frame >= 0; frame--) {\n\t        if (kfPercents[frame] <= percent) {\n\t          break;\n\t        }\n\t      } // PENDING really need to do this ?\n\t\n\t\n\t      frame = Math.min(frame, trackLen - 2);\n\t    } else {\n\t      for (frame = lastFrame; frame < trackLen; frame++) {\n\t        if (kfPercents[frame] > percent) {\n\t          break;\n\t        }\n\t      }\n\t\n\t      frame = Math.min(frame - 1, trackLen - 2);\n\t    }\n\t\n\t    lastFrame = frame;\n\t    lastFramePercent = percent;\n\t    var range = kfPercents[frame + 1] - kfPercents[frame];\n\t\n\t    if (range === 0) {\n\t      return;\n\t    } else {\n\t      w = (percent - kfPercents[frame]) / range;\n\t    }\n\t\n\t    if (useSpline) {\n\t      p1 = kfValues[frame];\n\t      p0 = kfValues[frame === 0 ? frame : frame - 1];\n\t      p2 = kfValues[frame > trackLen - 2 ? trackLen - 1 : frame + 1];\n\t      p3 = kfValues[frame > trackLen - 3 ? trackLen - 1 : frame + 2];\n\t\n\t      if (isValueArray) {\n\t        catmullRomInterpolateArray(p0, p1, p2, p3, w, w * w, w * w * w, getter(target, propName), arrDim);\n\t      } else {\n\t        var value;\n\t\n\t        if (isValueColor) {\n\t          value = catmullRomInterpolateArray(p0, p1, p2, p3, w, w * w, w * w * w, rgba, 1);\n\t          value = rgba2String(rgba);\n\t        } else if (isValueString) {\n\t          // String is step(0.5)\n\t          return interpolateString(p1, p2, w);\n\t        } else {\n\t          value = catmullRomInterpolate(p0, p1, p2, p3, w, w * w, w * w * w);\n\t        }\n\t\n\t        setter(target, propName, value);\n\t      }\n\t    } else {\n\t      if (isValueArray) {\n\t        interpolateArray(kfValues[frame], kfValues[frame + 1], w, getter(target, propName), arrDim);\n\t      } else {\n\t        var value;\n\t\n\t        if (isValueColor) {\n\t          interpolateArray(kfValues[frame], kfValues[frame + 1], w, rgba, 1);\n\t          value = rgba2String(rgba);\n\t        } else if (isValueString) {\n\t          // String is step(0.5)\n\t          return interpolateString(kfValues[frame], kfValues[frame + 1], w);\n\t        } else {\n\t          value = interpolateNumber(kfValues[frame], kfValues[frame + 1], w);\n\t        }\n\t\n\t        setter(target, propName, value);\n\t      }\n\t    }\n\t  };\n\t\n\t  var clip = new Clip({\n\t    target: animator._target,\n\t    life: trackMaxTime,\n\t    loop: animator._loop,\n\t    delay: animator._delay,\n\t    onframe: onframe,\n\t    ondestroy: oneTrackDone\n\t  });\n\t\n\t  if (easing && easing !== 'spline') {\n\t    clip.easing = easing;\n\t  }\n\t\n\t  return clip;\n\t}\n\t/**\n\t * @alias module:zrender/animation/Animator\n\t * @constructor\n\t * @param {Object} target\n\t * @param {boolean} loop\n\t * @param {Function} getter\n\t * @param {Function} setter\n\t */\n\t\n\t\n\tvar Animator = function (target, loop, getter, setter) {\n\t  this._tracks = {};\n\t  this._target = target;\n\t  this._loop = loop || false;\n\t  this._getter = getter || defaultGetter;\n\t  this._setter = setter || defaultSetter;\n\t  this._clipCount = 0;\n\t  this._delay = 0;\n\t  this._doneList = [];\n\t  this._onframeList = [];\n\t  this._clipList = [];\n\t};\n\t\n\tAnimator.prototype = {\n\t  /**\n\t   * 设置动画关键帧\n\t   * @param  {number} time 关键帧时间，单位是ms\n\t   * @param  {Object} props 关键帧的属性值，key-value表示\n\t   * @return {module:zrender/animation/Animator}\n\t   */\n\t  when: function (time\n\t  /* ms */\n\t  , props) {\n\t    var tracks = this._tracks;\n\t\n\t    for (var propName in props) {\n\t      if (!props.hasOwnProperty(propName)) {\n\t        continue;\n\t      }\n\t\n\t      if (!tracks[propName]) {\n\t        tracks[propName] = []; // Invalid value\n\t\n\t        var value = this._getter(this._target, propName);\n\t\n\t        if (value == null) {\n\t          // zrLog('Invalid property ' + propName);\n\t          continue;\n\t        } // If time is 0\n\t        //  Then props is given initialize value\n\t        // Else\n\t        //  Initialize value from current prop value\n\t\n\t\n\t        if (time !== 0) {\n\t          tracks[propName].push({\n\t            time: 0,\n\t            value: cloneValue(value)\n\t          });\n\t        }\n\t      }\n\t\n\t      tracks[propName].push({\n\t        time: time,\n\t        value: props[propName]\n\t      });\n\t    }\n\t\n\t    return this;\n\t  },\n\t\n\t  /**\n\t   * 添加动画每一帧的回调函数\n\t   * @param  {Function} callback\n\t   * @return {module:zrender/animation/Animator}\n\t   */\n\t  during: function (callback) {\n\t    this._onframeList.push(callback);\n\t\n\t    return this;\n\t  },\n\t  pause: function () {\n\t    for (var i = 0; i < this._clipList.length; i++) {\n\t      this._clipList[i].pause();\n\t    }\n\t\n\t    this._paused = true;\n\t  },\n\t  resume: function () {\n\t    for (var i = 0; i < this._clipList.length; i++) {\n\t      this._clipList[i].resume();\n\t    }\n\t\n\t    this._paused = false;\n\t  },\n\t  isPaused: function () {\n\t    return !!this._paused;\n\t  },\n\t  _doneCallback: function () {\n\t    // Clear all tracks\n\t    this._tracks = {}; // Clear all clips\n\t\n\t    this._clipList.length = 0;\n\t    var doneList = this._doneList;\n\t    var len = doneList.length;\n\t\n\t    for (var i = 0; i < len; i++) {\n\t      doneList[i].call(this);\n\t    }\n\t  },\n\t\n\t  /**\n\t   * 开始执行动画\n\t   * @param  {string|Function} [easing]\n\t   *         动画缓动函数，详见{@link module:zrender/animation/easing}\n\t   * @param  {boolean} forceAnimate\n\t   * @return {module:zrender/animation/Animator}\n\t   */\n\t  start: function (easing, forceAnimate) {\n\t    var self = this;\n\t    var clipCount = 0;\n\t\n\t    var oneTrackDone = function () {\n\t      clipCount--;\n\t\n\t      if (!clipCount) {\n\t        self._doneCallback();\n\t      }\n\t    };\n\t\n\t    var lastClip;\n\t\n\t    for (var propName in this._tracks) {\n\t      if (!this._tracks.hasOwnProperty(propName)) {\n\t        continue;\n\t      }\n\t\n\t      var clip = createTrackClip(this, easing, oneTrackDone, this._tracks[propName], propName, forceAnimate);\n\t\n\t      if (clip) {\n\t        this._clipList.push(clip);\n\t\n\t        clipCount++; // If start after added to animation\n\t\n\t        if (this.animation) {\n\t          this.animation.addClip(clip);\n\t        }\n\t\n\t        lastClip = clip;\n\t      }\n\t    } // Add during callback on the last clip\n\t\n\t\n\t    if (lastClip) {\n\t      var oldOnFrame = lastClip.onframe;\n\t\n\t      lastClip.onframe = function (target, percent) {\n\t        oldOnFrame(target, percent);\n\t\n\t        for (var i = 0; i < self._onframeList.length; i++) {\n\t          self._onframeList[i](target, percent);\n\t        }\n\t      };\n\t    } // This optimization will help the case that in the upper application\n\t    // the view may be refreshed frequently, where animation will be\n\t    // called repeatly but nothing changed.\n\t\n\t\n\t    if (!clipCount) {\n\t      this._doneCallback();\n\t    }\n\t\n\t    return this;\n\t  },\n\t\n\t  /**\n\t   * 停止动画\n\t   * @param {boolean} forwardToLast If move to last frame before stop\n\t   */\n\t  stop: function (forwardToLast) {\n\t    var clipList = this._clipList;\n\t    var animation = this.animation;\n\t\n\t    for (var i = 0; i < clipList.length; i++) {\n\t      var clip = clipList[i];\n\t\n\t      if (forwardToLast) {\n\t        // Move to last frame before stop\n\t        clip.onframe(this._target, 1);\n\t      }\n\t\n\t      animation && animation.removeClip(clip);\n\t    }\n\t\n\t    clipList.length = 0;\n\t  },\n\t\n\t  /**\n\t   * 设置动画延迟开始的时间\n\t   * @param  {number} time 单位ms\n\t   * @return {module:zrender/animation/Animator}\n\t   */\n\t  delay: function (time) {\n\t    this._delay = time;\n\t    return this;\n\t  },\n\t\n\t  /**\n\t   * 添加动画结束的回调\n\t   * @param  {Function} cb\n\t   * @return {module:zrender/animation/Animator}\n\t   */\n\t  done: function (cb) {\n\t    if (cb) {\n\t      this._doneList.push(cb);\n\t    }\n\t\n\t    return this;\n\t  },\n\t\n\t  /**\n\t   * @return {Array.<module:zrender/animation/Clip>}\n\t   */\n\t  getClips: function () {\n\t    return this._clipList;\n\t  }\n\t};\n\tvar _default = Animator;\n\tmodule.exports = _default;\n\n/***/ },\n/* 36 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar easingFuncs = __webpack_require__(37);\n\t\n\t/**\n\t * 动画主控制器\n\t * @config target 动画对象，可以是数组，如果是数组的话会批量分发onframe等事件\n\t * @config life(1000) 动画时长\n\t * @config delay(0) 动画延迟时间\n\t * @config loop(true)\n\t * @config gap(0) 循环的间隔时间\n\t * @config onframe\n\t * @config easing(optional)\n\t * @config ondestroy(optional)\n\t * @config onrestart(optional)\n\t *\n\t * TODO pause\n\t */\n\tfunction Clip(options) {\n\t  this._target = options.target; // 生命周期\n\t\n\t  this._life = options.life || 1000; // 延时\n\t\n\t  this._delay = options.delay || 0; // 开始时间\n\t  // this._startTime = new Date().getTime() + this._delay;// 单位毫秒\n\t\n\t  this._initialized = false; // 是否循环\n\t\n\t  this.loop = options.loop == null ? false : options.loop;\n\t  this.gap = options.gap || 0;\n\t  this.easing = options.easing || 'Linear';\n\t  this.onframe = options.onframe;\n\t  this.ondestroy = options.ondestroy;\n\t  this.onrestart = options.onrestart;\n\t  this._pausedTime = 0;\n\t  this._paused = false;\n\t}\n\t\n\tClip.prototype = {\n\t  constructor: Clip,\n\t  step: function (globalTime, deltaTime) {\n\t    // Set startTime on first step, or _startTime may has milleseconds different between clips\n\t    // PENDING\n\t    if (!this._initialized) {\n\t      this._startTime = globalTime + this._delay;\n\t      this._initialized = true;\n\t    }\n\t\n\t    if (this._paused) {\n\t      this._pausedTime += deltaTime;\n\t      return;\n\t    }\n\t\n\t    var percent = (globalTime - this._startTime - this._pausedTime) / this._life; // 还没开始\n\t\n\t    if (percent < 0) {\n\t      return;\n\t    }\n\t\n\t    percent = Math.min(percent, 1);\n\t    var easing = this.easing;\n\t    var easingFunc = typeof easing == 'string' ? easingFuncs[easing] : easing;\n\t    var schedule = typeof easingFunc === 'function' ? easingFunc(percent) : percent;\n\t    this.fire('frame', schedule); // 结束\n\t\n\t    if (percent == 1) {\n\t      if (this.loop) {\n\t        this.restart(globalTime); // 重新开始周期\n\t        // 抛出而不是直接调用事件直到 stage.update 后再统一调用这些事件\n\t\n\t        return 'restart';\n\t      } // 动画完成将这个控制器标识为待删除\n\t      // 在Animation.update中进行批量删除\n\t\n\t\n\t      this._needsRemove = true;\n\t      return 'destroy';\n\t    }\n\t\n\t    return null;\n\t  },\n\t  restart: function (globalTime) {\n\t    var remainder = (globalTime - this._startTime - this._pausedTime) % this._life;\n\t    this._startTime = globalTime - remainder + this.gap;\n\t    this._pausedTime = 0;\n\t    this._needsRemove = false;\n\t  },\n\t  fire: function (eventType, arg) {\n\t    eventType = 'on' + eventType;\n\t\n\t    if (this[eventType]) {\n\t      this[eventType](this._target, arg);\n\t    }\n\t  },\n\t  pause: function () {\n\t    this._paused = true;\n\t  },\n\t  resume: function () {\n\t    this._paused = false;\n\t  }\n\t};\n\tvar _default = Clip;\n\tmodule.exports = _default;\n\n/***/ },\n/* 37 */\n/***/ function(module, exports) {\n\n\t/**\n\t * 缓动代码来自 https://github.com/sole/tween.js/blob/master/src/Tween.js\n\t * @see http://sole.github.io/tween.js/examples/03_graphs.html\n\t * @exports zrender/animation/easing\n\t */\n\tvar easing = {\n\t  /**\n\t  * @param {number} k\n\t  * @return {number}\n\t  */\n\t  linear: function (k) {\n\t    return k;\n\t  },\n\t\n\t  /**\n\t  * @param {number} k\n\t  * @return {number}\n\t  */\n\t  quadraticIn: function (k) {\n\t    return k * k;\n\t  },\n\t\n\t  /**\n\t  * @param {number} k\n\t  * @return {number}\n\t  */\n\t  quadraticOut: function (k) {\n\t    return k * (2 - k);\n\t  },\n\t\n\t  /**\n\t  * @param {number} k\n\t  * @return {number}\n\t  */\n\t  quadraticInOut: function (k) {\n\t    if ((k *= 2) < 1) {\n\t      return 0.5 * k * k;\n\t    }\n\t\n\t    return -0.5 * (--k * (k - 2) - 1);\n\t  },\n\t  // 三次方的缓动（t^3）\n\t\n\t  /**\n\t  * @param {number} k\n\t  * @return {number}\n\t  */\n\t  cubicIn: function (k) {\n\t    return k * k * k;\n\t  },\n\t\n\t  /**\n\t  * @param {number} k\n\t  * @return {number}\n\t  */\n\t  cubicOut: function (k) {\n\t    return --k * k * k + 1;\n\t  },\n\t\n\t  /**\n\t  * @param {number} k\n\t  * @return {number}\n\t  */\n\t  cubicInOut: function (k) {\n\t    if ((k *= 2) < 1) {\n\t      return 0.5 * k * k * k;\n\t    }\n\t\n\t    return 0.5 * ((k -= 2) * k * k + 2);\n\t  },\n\t  // 四次方的缓动（t^4）\n\t\n\t  /**\n\t  * @param {number} k\n\t  * @return {number}\n\t  */\n\t  quarticIn: function (k) {\n\t    return k * k * k * k;\n\t  },\n\t\n\t  /**\n\t  * @param {number} k\n\t  * @return {number}\n\t  */\n\t  quarticOut: function (k) {\n\t    return 1 - --k * k * k * k;\n\t  },\n\t\n\t  /**\n\t  * @param {number} k\n\t  * @return {number}\n\t  */\n\t  quarticInOut: function (k) {\n\t    if ((k *= 2) < 1) {\n\t      return 0.5 * k * k * k * k;\n\t    }\n\t\n\t    return -0.5 * ((k -= 2) * k * k * k - 2);\n\t  },\n\t  // 五次方的缓动（t^5）\n\t\n\t  /**\n\t  * @param {number} k\n\t  * @return {number}\n\t  */\n\t  quinticIn: function (k) {\n\t    return k * k * k * k * k;\n\t  },\n\t\n\t  /**\n\t  * @param {number} k\n\t  * @return {number}\n\t  */\n\t  quinticOut: function (k) {\n\t    return --k * k * k * k * k + 1;\n\t  },\n\t\n\t  /**\n\t  * @param {number} k\n\t  * @return {number}\n\t  */\n\t  quinticInOut: function (k) {\n\t    if ((k *= 2) < 1) {\n\t      return 0.5 * k * k * k * k * k;\n\t    }\n\t\n\t    return 0.5 * ((k -= 2) * k * k * k * k + 2);\n\t  },\n\t  // 正弦曲线的缓动（sin(t)）\n\t\n\t  /**\n\t  * @param {number} k\n\t  * @return {number}\n\t  */\n\t  sinusoidalIn: function (k) {\n\t    return 1 - Math.cos(k * Math.PI / 2);\n\t  },\n\t\n\t  /**\n\t  * @param {number} k\n\t  * @return {number}\n\t  */\n\t  sinusoidalOut: function (k) {\n\t    return Math.sin(k * Math.PI / 2);\n\t  },\n\t\n\t  /**\n\t  * @param {number} k\n\t  * @return {number}\n\t  */\n\t  sinusoidalInOut: function (k) {\n\t    return 0.5 * (1 - Math.cos(Math.PI * k));\n\t  },\n\t  // 指数曲线的缓动（2^t）\n\t\n\t  /**\n\t  * @param {number} k\n\t  * @return {number}\n\t  */\n\t  exponentialIn: function (k) {\n\t    return k === 0 ? 0 : Math.pow(1024, k - 1);\n\t  },\n\t\n\t  /**\n\t  * @param {number} k\n\t  * @return {number}\n\t  */\n\t  exponentialOut: function (k) {\n\t    return k === 1 ? 1 : 1 - Math.pow(2, -10 * k);\n\t  },\n\t\n\t  /**\n\t  * @param {number} k\n\t  * @return {number}\n\t  */\n\t  exponentialInOut: function (k) {\n\t    if (k === 0) {\n\t      return 0;\n\t    }\n\t\n\t    if (k === 1) {\n\t      return 1;\n\t    }\n\t\n\t    if ((k *= 2) < 1) {\n\t      return 0.5 * Math.pow(1024, k - 1);\n\t    }\n\t\n\t    return 0.5 * (-Math.pow(2, -10 * (k - 1)) + 2);\n\t  },\n\t  // 圆形曲线的缓动（sqrt(1-t^2)）\n\t\n\t  /**\n\t  * @param {number} k\n\t  * @return {number}\n\t  */\n\t  circularIn: function (k) {\n\t    return 1 - Math.sqrt(1 - k * k);\n\t  },\n\t\n\t  /**\n\t  * @param {number} k\n\t  * @return {number}\n\t  */\n\t  circularOut: function (k) {\n\t    return Math.sqrt(1 - --k * k);\n\t  },\n\t\n\t  /**\n\t  * @param {number} k\n\t  * @return {number}\n\t  */\n\t  circularInOut: function (k) {\n\t    if ((k *= 2) < 1) {\n\t      return -0.5 * (Math.sqrt(1 - k * k) - 1);\n\t    }\n\t\n\t    return 0.5 * (Math.sqrt(1 - (k -= 2) * k) + 1);\n\t  },\n\t  // 创建类似于弹簧在停止前来回振荡的动画\n\t\n\t  /**\n\t  * @param {number} k\n\t  * @return {number}\n\t  */\n\t  elasticIn: function (k) {\n\t    var s;\n\t    var a = 0.1;\n\t    var p = 0.4;\n\t\n\t    if (k === 0) {\n\t      return 0;\n\t    }\n\t\n\t    if (k === 1) {\n\t      return 1;\n\t    }\n\t\n\t    if (!a || a < 1) {\n\t      a = 1;\n\t      s = p / 4;\n\t    } else {\n\t      s = p * Math.asin(1 / a) / (2 * Math.PI);\n\t    }\n\t\n\t    return -(a * Math.pow(2, 10 * (k -= 1)) * Math.sin((k - s) * (2 * Math.PI) / p));\n\t  },\n\t\n\t  /**\n\t  * @param {number} k\n\t  * @return {number}\n\t  */\n\t  elasticOut: function (k) {\n\t    var s;\n\t    var a = 0.1;\n\t    var p = 0.4;\n\t\n\t    if (k === 0) {\n\t      return 0;\n\t    }\n\t\n\t    if (k === 1) {\n\t      return 1;\n\t    }\n\t\n\t    if (!a || a < 1) {\n\t      a = 1;\n\t      s = p / 4;\n\t    } else {\n\t      s = p * Math.asin(1 / a) / (2 * Math.PI);\n\t    }\n\t\n\t    return a * Math.pow(2, -10 * k) * Math.sin((k - s) * (2 * Math.PI) / p) + 1;\n\t  },\n\t\n\t  /**\n\t  * @param {number} k\n\t  * @return {number}\n\t  */\n\t  elasticInOut: function (k) {\n\t    var s;\n\t    var a = 0.1;\n\t    var p = 0.4;\n\t\n\t    if (k === 0) {\n\t      return 0;\n\t    }\n\t\n\t    if (k === 1) {\n\t      return 1;\n\t    }\n\t\n\t    if (!a || a < 1) {\n\t      a = 1;\n\t      s = p / 4;\n\t    } else {\n\t      s = p * Math.asin(1 / a) / (2 * Math.PI);\n\t    }\n\t\n\t    if ((k *= 2) < 1) {\n\t      return -0.5 * (a * Math.pow(2, 10 * (k -= 1)) * Math.sin((k - s) * (2 * Math.PI) / p));\n\t    }\n\t\n\t    return a * Math.pow(2, -10 * (k -= 1)) * Math.sin((k - s) * (2 * Math.PI) / p) * 0.5 + 1;\n\t  },\n\t  // 在某一动画开始沿指示的路径进行动画处理前稍稍收回该动画的移动\n\t\n\t  /**\n\t  * @param {number} k\n\t  * @return {number}\n\t  */\n\t  backIn: function (k) {\n\t    var s = 1.70158;\n\t    return k * k * ((s + 1) * k - s);\n\t  },\n\t\n\t  /**\n\t  * @param {number} k\n\t  * @return {number}\n\t  */\n\t  backOut: function (k) {\n\t    var s = 1.70158;\n\t    return --k * k * ((s + 1) * k + s) + 1;\n\t  },\n\t\n\t  /**\n\t  * @param {number} k\n\t  * @return {number}\n\t  */\n\t  backInOut: function (k) {\n\t    var s = 1.70158 * 1.525;\n\t\n\t    if ((k *= 2) < 1) {\n\t      return 0.5 * (k * k * ((s + 1) * k - s));\n\t    }\n\t\n\t    return 0.5 * ((k -= 2) * k * ((s + 1) * k + s) + 2);\n\t  },\n\t  // 创建弹跳效果\n\t\n\t  /**\n\t  * @param {number} k\n\t  * @return {number}\n\t  */\n\t  bounceIn: function (k) {\n\t    return 1 - easing.bounceOut(1 - k);\n\t  },\n\t\n\t  /**\n\t  * @param {number} k\n\t  * @return {number}\n\t  */\n\t  bounceOut: function (k) {\n\t    if (k < 1 / 2.75) {\n\t      return 7.5625 * k * k;\n\t    } else if (k < 2 / 2.75) {\n\t      return 7.5625 * (k -= 1.5 / 2.75) * k + 0.75;\n\t    } else if (k < 2.5 / 2.75) {\n\t      return 7.5625 * (k -= 2.25 / 2.75) * k + 0.9375;\n\t    } else {\n\t      return 7.5625 * (k -= 2.625 / 2.75) * k + 0.984375;\n\t    }\n\t  },\n\t\n\t  /**\n\t  * @param {number} k\n\t  * @return {number}\n\t  */\n\t  bounceInOut: function (k) {\n\t    if (k < 0.5) {\n\t      return easing.bounceIn(k * 2) * 0.5;\n\t    }\n\t\n\t    return easing.bounceOut(k * 2 - 1) * 0.5 + 0.5;\n\t  }\n\t};\n\tvar _default = easing;\n\tmodule.exports = _default;\n\n/***/ },\n/* 38 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar _util = __webpack_require__(18);\n\t\n\tvar normalizeRadian = _util.normalizeRadian;\n\tvar PI2 = Math.PI * 2;\n\t/**\n\t * 圆弧描边包含判断\n\t * @param  {number}  cx\n\t * @param  {number}  cy\n\t * @param  {number}  r\n\t * @param  {number}  startAngle\n\t * @param  {number}  endAngle\n\t * @param  {boolean}  anticlockwise\n\t * @param  {number} lineWidth\n\t * @param  {number}  x\n\t * @param  {number}  y\n\t * @return {Boolean}\n\t */\n\t\n\tfunction containStroke(cx, cy, r, startAngle, endAngle, anticlockwise, lineWidth, x, y) {\n\t  if (lineWidth === 0) {\n\t    return false;\n\t  }\n\t\n\t  var _l = lineWidth;\n\t  x -= cx;\n\t  y -= cy;\n\t  var d = Math.sqrt(x * x + y * y);\n\t\n\t  if (d - _l > r || d + _l < r) {\n\t    return false;\n\t  }\n\t\n\t  if (Math.abs(startAngle - endAngle) % PI2 < 1e-4) {\n\t    // Is a circle\n\t    return true;\n\t  }\n\t\n\t  if (anticlockwise) {\n\t    var tmp = startAngle;\n\t    startAngle = normalizeRadian(endAngle);\n\t    endAngle = normalizeRadian(tmp);\n\t  } else {\n\t    startAngle = normalizeRadian(startAngle);\n\t    endAngle = normalizeRadian(endAngle);\n\t  }\n\t\n\t  if (startAngle > endAngle) {\n\t    endAngle += PI2;\n\t  }\n\t\n\t  var angle = Math.atan2(y, x);\n\t\n\t  if (angle < 0) {\n\t    angle += PI2;\n\t  }\n\t\n\t  return angle >= startAngle && angle <= endAngle || angle + PI2 >= startAngle && angle + PI2 <= endAngle;\n\t}\n\t\n\texports.containStroke = containStroke;\n\n/***/ },\n/* 39 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar curve = __webpack_require__(5);\n\t\n\t/**\n\t * 三次贝塞尔曲线描边包含判断\n\t * @param  {number}  x0\n\t * @param  {number}  y0\n\t * @param  {number}  x1\n\t * @param  {number}  y1\n\t * @param  {number}  x2\n\t * @param  {number}  y2\n\t * @param  {number}  x3\n\t * @param  {number}  y3\n\t * @param  {number}  lineWidth\n\t * @param  {number}  x\n\t * @param  {number}  y\n\t * @return {boolean}\n\t */\n\tfunction containStroke(x0, y0, x1, y1, x2, y2, x3, y3, lineWidth, x, y) {\n\t  if (lineWidth === 0) {\n\t    return false;\n\t  }\n\t\n\t  var _l = lineWidth; // Quick reject\n\t\n\t  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\t    return false;\n\t  }\n\t\n\t  var d = curve.cubicProjectPoint(x0, y0, x1, y1, x2, y2, x3, y3, x, y, null);\n\t  return d <= _l / 2;\n\t}\n\t\n\texports.containStroke = containStroke;\n\n/***/ },\n/* 40 */\n/***/ function(module, exports) {\n\n\t/**\n\t * 线段包含判断\n\t * @param  {number}  x0\n\t * @param  {number}  y0\n\t * @param  {number}  x1\n\t * @param  {number}  y1\n\t * @param  {number}  lineWidth\n\t * @param  {number}  x\n\t * @param  {number}  y\n\t * @return {boolean}\n\t */\n\tfunction containStroke(x0, y0, x1, y1, lineWidth, x, y) {\n\t  if (lineWidth === 0) {\n\t    return false;\n\t  }\n\t\n\t  var _l = lineWidth;\n\t  var _a = 0;\n\t  var _b = x0; // Quick reject\n\t\n\t  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\t    return false;\n\t  }\n\t\n\t  if (x0 !== x1) {\n\t    _a = (y0 - y1) / (x0 - x1);\n\t    _b = (x0 * y1 - x1 * y0) / (x0 - x1);\n\t  } else {\n\t    return Math.abs(x - x0) <= _l / 2;\n\t  }\n\t\n\t  var tmp = _a * x - y + _b;\n\t\n\t  var _s = tmp * tmp / (_a * _a + 1);\n\t\n\t  return _s <= _l / 2 * _l / 2;\n\t}\n\t\n\texports.containStroke = containStroke;\n\n/***/ },\n/* 41 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar PathProxy = __webpack_require__(7);\n\t\n\tvar line = __webpack_require__(40);\n\t\n\tvar cubic = __webpack_require__(39);\n\t\n\tvar quadratic = __webpack_require__(42);\n\t\n\tvar arc = __webpack_require__(38);\n\t\n\tvar _util = __webpack_require__(18);\n\t\n\tvar normalizeRadian = _util.normalizeRadian;\n\t\n\tvar curve = __webpack_require__(5);\n\t\n\tvar windingLine = __webpack_require__(43);\n\t\n\tvar CMD = PathProxy.CMD;\n\tvar PI2 = Math.PI * 2;\n\tvar EPSILON = 1e-4;\n\t\n\tfunction isAroundEqual(a, b) {\n\t  return Math.abs(a - b) < EPSILON;\n\t} // 临时数组\n\t\n\t\n\tvar roots = [-1, -1, -1];\n\tvar extrema = [-1, -1];\n\t\n\tfunction swapExtrema() {\n\t  var tmp = extrema[0];\n\t  extrema[0] = extrema[1];\n\t  extrema[1] = tmp;\n\t}\n\t\n\tfunction windingCubic(x0, y0, x1, y1, x2, y2, x3, y3, x, y) {\n\t  // Quick reject\n\t  if (y > y0 && y > y1 && y > y2 && y > y3 || y < y0 && y < y1 && y < y2 && y < y3) {\n\t    return 0;\n\t  }\n\t\n\t  var nRoots = curve.cubicRootAt(y0, y1, y2, y3, y, roots);\n\t\n\t  if (nRoots === 0) {\n\t    return 0;\n\t  } else {\n\t    var w = 0;\n\t    var nExtrema = -1;\n\t    var y0_, y1_;\n\t\n\t    for (var i = 0; i < nRoots; i++) {\n\t      var t = roots[i]; // Avoid winding error when intersection point is the connect point of two line of polygon\n\t\n\t      var unit = t === 0 || t === 1 ? 0.5 : 1;\n\t      var x_ = curve.cubicAt(x0, x1, x2, x3, t);\n\t\n\t      if (x_ < x) {\n\t        // Quick reject\n\t        continue;\n\t      }\n\t\n\t      if (nExtrema < 0) {\n\t        nExtrema = curve.cubicExtrema(y0, y1, y2, y3, extrema);\n\t\n\t        if (extrema[1] < extrema[0] && nExtrema > 1) {\n\t          swapExtrema();\n\t        }\n\t\n\t        y0_ = curve.cubicAt(y0, y1, y2, y3, extrema[0]);\n\t\n\t        if (nExtrema > 1) {\n\t          y1_ = curve.cubicAt(y0, y1, y2, y3, extrema[1]);\n\t        }\n\t      }\n\t\n\t      if (nExtrema == 2) {\n\t        // 分成三段单调函数\n\t        if (t < extrema[0]) {\n\t          w += y0_ < y0 ? unit : -unit;\n\t        } else if (t < extrema[1]) {\n\t          w += y1_ < y0_ ? unit : -unit;\n\t        } else {\n\t          w += y3 < y1_ ? unit : -unit;\n\t        }\n\t      } else {\n\t        // 分成两段单调函数\n\t        if (t < extrema[0]) {\n\t          w += y0_ < y0 ? unit : -unit;\n\t        } else {\n\t          w += y3 < y0_ ? unit : -unit;\n\t        }\n\t      }\n\t    }\n\t\n\t    return w;\n\t  }\n\t}\n\t\n\tfunction windingQuadratic(x0, y0, x1, y1, x2, y2, x, y) {\n\t  // Quick reject\n\t  if (y > y0 && y > y1 && y > y2 || y < y0 && y < y1 && y < y2) {\n\t    return 0;\n\t  }\n\t\n\t  var nRoots = curve.quadraticRootAt(y0, y1, y2, y, roots);\n\t\n\t  if (nRoots === 0) {\n\t    return 0;\n\t  } else {\n\t    var t = curve.quadraticExtremum(y0, y1, y2);\n\t\n\t    if (t >= 0 && t <= 1) {\n\t      var w = 0;\n\t      var y_ = curve.quadraticAt(y0, y1, y2, t);\n\t\n\t      for (var i = 0; i < nRoots; i++) {\n\t        // Remove one endpoint.\n\t        var unit = roots[i] === 0 || roots[i] === 1 ? 0.5 : 1;\n\t        var x_ = curve.quadraticAt(x0, x1, x2, roots[i]);\n\t\n\t        if (x_ < x) {\n\t          // Quick reject\n\t          continue;\n\t        }\n\t\n\t        if (roots[i] < t) {\n\t          w += y_ < y0 ? unit : -unit;\n\t        } else {\n\t          w += y2 < y_ ? unit : -unit;\n\t        }\n\t      }\n\t\n\t      return w;\n\t    } else {\n\t      // Remove one endpoint.\n\t      var unit = roots[0] === 0 || roots[0] === 1 ? 0.5 : 1;\n\t      var x_ = curve.quadraticAt(x0, x1, x2, roots[0]);\n\t\n\t      if (x_ < x) {\n\t        // Quick reject\n\t        return 0;\n\t      }\n\t\n\t      return y2 < y0 ? unit : -unit;\n\t    }\n\t  }\n\t} // TODO\n\t// Arc 旋转\n\t\n\t\n\tfunction windingArc(cx, cy, r, startAngle, endAngle, anticlockwise, x, y) {\n\t  y -= cy;\n\t\n\t  if (y > r || y < -r) {\n\t    return 0;\n\t  }\n\t\n\t  var tmp = Math.sqrt(r * r - y * y);\n\t  roots[0] = -tmp;\n\t  roots[1] = tmp;\n\t  var diff = Math.abs(startAngle - endAngle);\n\t\n\t  if (diff < 1e-4) {\n\t    return 0;\n\t  }\n\t\n\t  if (diff % PI2 < 1e-4) {\n\t    // Is a circle\n\t    startAngle = 0;\n\t    endAngle = PI2;\n\t    var dir = anticlockwise ? 1 : -1;\n\t\n\t    if (x >= roots[0] + cx && x <= roots[1] + cx) {\n\t      return dir;\n\t    } else {\n\t      return 0;\n\t    }\n\t  }\n\t\n\t  if (anticlockwise) {\n\t    var tmp = startAngle;\n\t    startAngle = normalizeRadian(endAngle);\n\t    endAngle = normalizeRadian(tmp);\n\t  } else {\n\t    startAngle = normalizeRadian(startAngle);\n\t    endAngle = normalizeRadian(endAngle);\n\t  }\n\t\n\t  if (startAngle > endAngle) {\n\t    endAngle += PI2;\n\t  }\n\t\n\t  var w = 0;\n\t\n\t  for (var i = 0; i < 2; i++) {\n\t    var x_ = roots[i];\n\t\n\t    if (x_ + cx > x) {\n\t      var angle = Math.atan2(y, x_);\n\t      var dir = anticlockwise ? 1 : -1;\n\t\n\t      if (angle < 0) {\n\t        angle = PI2 + angle;\n\t      }\n\t\n\t      if (angle >= startAngle && angle <= endAngle || angle + PI2 >= startAngle && angle + PI2 <= endAngle) {\n\t        if (angle > Math.PI / 2 && angle < Math.PI * 1.5) {\n\t          dir = -dir;\n\t        }\n\t\n\t        w += dir;\n\t      }\n\t    }\n\t  }\n\t\n\t  return w;\n\t}\n\t\n\tfunction containPath(data, lineWidth, isStroke, x, y) {\n\t  var w = 0;\n\t  var xi = 0;\n\t  var yi = 0;\n\t  var x0 = 0;\n\t  var y0 = 0;\n\t\n\t  for (var i = 0; i < data.length;) {\n\t    var cmd = data[i++]; // Begin a new subpath\n\t\n\t    if (cmd === CMD.M && i > 1) {\n\t      // Close previous subpath\n\t      if (!isStroke) {\n\t        w += windingLine(xi, yi, x0, y0, x, y);\n\t      } // 如果被任何一个 subpath 包含\n\t      // if (w !== 0) {\n\t      //     return true;\n\t      // }\n\t\n\t    }\n\t\n\t    if (i == 1) {\n\t      // 如果第一个命令是 L, C, Q\n\t      // 则 previous point 同绘制命令的第一个 point\n\t      //\n\t      // 第一个命令为 Arc 的情况下会在后面特殊处理\n\t      xi = data[i];\n\t      yi = data[i + 1];\n\t      x0 = xi;\n\t      y0 = yi;\n\t    }\n\t\n\t    switch (cmd) {\n\t      case CMD.M:\n\t        // moveTo 命令重新创建一个新的 subpath, 并且更新新的起点\n\t        // 在 closePath 的时候使用\n\t        x0 = data[i++];\n\t        y0 = data[i++];\n\t        xi = x0;\n\t        yi = y0;\n\t        break;\n\t\n\t      case CMD.L:\n\t        if (isStroke) {\n\t          if (line.containStroke(xi, yi, data[i], data[i + 1], lineWidth, x, y)) {\n\t            return true;\n\t          }\n\t        } else {\n\t          // NOTE 在第一个命令为 L, C, Q 的时候会计算出 NaN\n\t          w += windingLine(xi, yi, data[i], data[i + 1], x, y) || 0;\n\t        }\n\t\n\t        xi = data[i++];\n\t        yi = data[i++];\n\t        break;\n\t\n\t      case CMD.C:\n\t        if (isStroke) {\n\t          if (cubic.containStroke(xi, yi, data[i++], data[i++], data[i++], data[i++], data[i], data[i + 1], lineWidth, x, y)) {\n\t            return true;\n\t          }\n\t        } else {\n\t          w += windingCubic(xi, yi, data[i++], data[i++], data[i++], data[i++], data[i], data[i + 1], x, y) || 0;\n\t        }\n\t\n\t        xi = data[i++];\n\t        yi = data[i++];\n\t        break;\n\t\n\t      case CMD.Q:\n\t        if (isStroke) {\n\t          if (quadratic.containStroke(xi, yi, data[i++], data[i++], data[i], data[i + 1], lineWidth, x, y)) {\n\t            return true;\n\t          }\n\t        } else {\n\t          w += windingQuadratic(xi, yi, data[i++], data[i++], data[i], data[i + 1], x, y) || 0;\n\t        }\n\t\n\t        xi = data[i++];\n\t        yi = data[i++];\n\t        break;\n\t\n\t      case CMD.A:\n\t        // TODO Arc 判断的开销比较大\n\t        var cx = data[i++];\n\t        var cy = data[i++];\n\t        var rx = data[i++];\n\t        var ry = data[i++];\n\t        var theta = data[i++];\n\t        var dTheta = data[i++]; // TODO Arc 旋转\n\t\n\t        var psi = data[i++];\n\t        var anticlockwise = 1 - data[i++];\n\t        var x1 = Math.cos(theta) * rx + cx;\n\t        var y1 = Math.sin(theta) * ry + cy; // 不是直接使用 arc 命令\n\t\n\t        if (i > 1) {\n\t          w += windingLine(xi, yi, x1, y1, x, y);\n\t        } else {\n\t          // 第一个命令起点还未定义\n\t          x0 = x1;\n\t          y0 = y1;\n\t        } // zr 使用scale来模拟椭圆, 这里也对x做一定的缩放\n\t\n\t\n\t        var _x = (x - cx) * ry / rx + cx;\n\t\n\t        if (isStroke) {\n\t          if (arc.containStroke(cx, cy, ry, theta, theta + dTheta, anticlockwise, lineWidth, _x, y)) {\n\t            return true;\n\t          }\n\t        } else {\n\t          w += windingArc(cx, cy, ry, theta, theta + dTheta, anticlockwise, _x, y);\n\t        }\n\t\n\t        xi = Math.cos(theta + dTheta) * rx + cx;\n\t        yi = Math.sin(theta + dTheta) * ry + cy;\n\t        break;\n\t\n\t      case CMD.R:\n\t        x0 = xi = data[i++];\n\t        y0 = yi = data[i++];\n\t        var width = data[i++];\n\t        var height = data[i++];\n\t        var x1 = x0 + width;\n\t        var y1 = y0 + height;\n\t\n\t        if (isStroke) {\n\t          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\t            return true;\n\t          }\n\t        } else {\n\t          // FIXME Clockwise ?\n\t          w += windingLine(x1, y0, x1, y1, x, y);\n\t          w += windingLine(x0, y1, x0, y0, x, y);\n\t        }\n\t\n\t        break;\n\t\n\t      case CMD.Z:\n\t        if (isStroke) {\n\t          if (line.containStroke(xi, yi, x0, y0, lineWidth, x, y)) {\n\t            return true;\n\t          }\n\t        } else {\n\t          // Close a subpath\n\t          w += windingLine(xi, yi, x0, y0, x, y); // 如果被任何一个 subpath 包含\n\t          // FIXME subpaths may overlap\n\t          // if (w !== 0) {\n\t          //     return true;\n\t          // }\n\t        }\n\t\n\t        xi = x0;\n\t        yi = y0;\n\t        break;\n\t    }\n\t  }\n\t\n\t  if (!isStroke && !isAroundEqual(yi, y0)) {\n\t    w += windingLine(xi, yi, x0, y0, x, y) || 0;\n\t  }\n\t\n\t  return w !== 0;\n\t}\n\t\n\tfunction contain(pathData, x, y) {\n\t  return containPath(pathData, 0, false, x, y);\n\t}\n\t\n\tfunction containStroke(pathData, lineWidth, x, y) {\n\t  return containPath(pathData, lineWidth, true, x, y);\n\t}\n\t\n\texports.contain = contain;\n\texports.containStroke = containStroke;\n\n/***/ },\n/* 42 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar _curve = __webpack_require__(5);\n\t\n\tvar quadraticProjectPoint = _curve.quadraticProjectPoint;\n\t\n\t/**\n\t * 二次贝塞尔曲线描边包含判断\n\t * @param  {number}  x0\n\t * @param  {number}  y0\n\t * @param  {number}  x1\n\t * @param  {number}  y1\n\t * @param  {number}  x2\n\t * @param  {number}  y2\n\t * @param  {number}  lineWidth\n\t * @param  {number}  x\n\t * @param  {number}  y\n\t * @return {boolean}\n\t */\n\tfunction containStroke(x0, y0, x1, y1, x2, y2, lineWidth, x, y) {\n\t  if (lineWidth === 0) {\n\t    return false;\n\t  }\n\t\n\t  var _l = lineWidth; // Quick reject\n\t\n\t  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\t    return false;\n\t  }\n\t\n\t  var d = quadraticProjectPoint(x0, y0, x1, y1, x2, y2, x, y, null);\n\t  return d <= _l / 2;\n\t}\n\t\n\texports.containStroke = containStroke;\n\n/***/ },\n/* 43 */\n/***/ function(module, exports) {\n\n\tfunction windingLine(x0, y0, x1, y1, x, y) {\n\t  if (y > y0 && y > y1 || y < y0 && y < y1) {\n\t    return 0;\n\t  } // Ignore horizontal line\n\t\n\t\n\t  if (y1 === y0) {\n\t    return 0;\n\t  }\n\t\n\t  var dir = y1 < y0 ? 1 : -1;\n\t  var t = (y - y0) / (y1 - y0); // Avoid winding error when intersection point is the connect point of two line of polygon\n\t\n\t  if (t === 1 || t === 0) {\n\t    dir = y1 < y0 ? 0.5 : -0.5;\n\t  }\n\t\n\t  var x_ = t * (x1 - x0) + x0;\n\t  return x_ > x ? dir : 0;\n\t}\n\t\n\tmodule.exports = windingLine;\n\n/***/ },\n/* 44 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar zrUtil = __webpack_require__(1);\n\t\n\tvar Element = __webpack_require__(15);\n\t\n\tvar BoundingRect = __webpack_require__(4);\n\t\n\t/**\n\t * Group是一个容器，可以插入子节点，Group的变换也会被应用到子节点上\n\t * @module zrender/graphic/Group\n\t * @example\n\t *     var Group = require('zrender/container/Group');\n\t *     var Circle = require('zrender/graphic/shape/Circle');\n\t *     var g = new Group();\n\t *     g.position[0] = 100;\n\t *     g.position[1] = 100;\n\t *     g.add(new Circle({\n\t *         style: {\n\t *             x: 100,\n\t *             y: 100,\n\t *             r: 20,\n\t *         }\n\t *     }));\n\t *     zr.add(g);\n\t */\n\t\n\t/**\n\t * @alias module:zrender/graphic/Group\n\t * @constructor\n\t * @extends module:zrender/mixin/Transformable\n\t * @extends module:zrender/mixin/Eventful\n\t */\n\tvar Group = function (opts) {\n\t  opts = opts || {};\n\t  Element.call(this, opts);\n\t\n\t  for (var key in opts) {\n\t    if (opts.hasOwnProperty(key)) {\n\t      this[key] = opts[key];\n\t    }\n\t  }\n\t\n\t  this._children = [];\n\t  this.__storage = null;\n\t  this.__dirty = true;\n\t};\n\t\n\tGroup.prototype = {\n\t  constructor: Group,\n\t  isGroup: true,\n\t\n\t  /**\n\t   * @type {string}\n\t   */\n\t  type: 'group',\n\t\n\t  /**\n\t   * 所有子孙元素是否响应鼠标事件\n\t   * @name module:/zrender/container/Group#silent\n\t   * @type {boolean}\n\t   * @default false\n\t   */\n\t  silent: false,\n\t\n\t  /**\n\t   * @return {Array.<module:zrender/Element>}\n\t   */\n\t  children: function () {\n\t    return this._children.slice();\n\t  },\n\t\n\t  /**\n\t   * 获取指定 index 的儿子节点\n\t   * @param  {number} idx\n\t   * @return {module:zrender/Element}\n\t   */\n\t  childAt: function (idx) {\n\t    return this._children[idx];\n\t  },\n\t\n\t  /**\n\t   * 获取指定名字的儿子节点\n\t   * @param  {string} name\n\t   * @return {module:zrender/Element}\n\t   */\n\t  childOfName: function (name) {\n\t    var children = this._children;\n\t\n\t    for (var i = 0; i < children.length; i++) {\n\t      if (children[i].name === name) {\n\t        return children[i];\n\t      }\n\t    }\n\t  },\n\t\n\t  /**\n\t   * @return {number}\n\t   */\n\t  childCount: function () {\n\t    return this._children.length;\n\t  },\n\t\n\t  /**\n\t   * 添加子节点到最后\n\t   * @param {module:zrender/Element} child\n\t   */\n\t  add: function (child) {\n\t    if (child && child !== this && child.parent !== this) {\n\t      this._children.push(child);\n\t\n\t      this._doAdd(child);\n\t    }\n\t\n\t    return this;\n\t  },\n\t\n\t  /**\n\t   * 添加子节点在 nextSibling 之前\n\t   * @param {module:zrender/Element} child\n\t   * @param {module:zrender/Element} nextSibling\n\t   */\n\t  addBefore: function (child, nextSibling) {\n\t    if (child && child !== this && child.parent !== this && nextSibling && nextSibling.parent === this) {\n\t      var children = this._children;\n\t      var idx = children.indexOf(nextSibling);\n\t\n\t      if (idx >= 0) {\n\t        children.splice(idx, 0, child);\n\t\n\t        this._doAdd(child);\n\t      }\n\t    }\n\t\n\t    return this;\n\t  },\n\t  _doAdd: function (child) {\n\t    if (child.parent) {\n\t      child.parent.remove(child);\n\t    }\n\t\n\t    child.parent = this;\n\t    var storage = this.__storage;\n\t    var zr = this.__zr;\n\t\n\t    if (storage && storage !== child.__storage) {\n\t      storage.addToStorage(child);\n\t\n\t      if (child instanceof Group) {\n\t        child.addChildrenToStorage(storage);\n\t      }\n\t    }\n\t\n\t    zr && zr.refresh();\n\t  },\n\t\n\t  /**\n\t   * 移除子节点\n\t   * @param {module:zrender/Element} child\n\t   */\n\t  remove: function (child) {\n\t    var zr = this.__zr;\n\t    var storage = this.__storage;\n\t    var children = this._children;\n\t    var idx = zrUtil.indexOf(children, child);\n\t\n\t    if (idx < 0) {\n\t      return this;\n\t    }\n\t\n\t    children.splice(idx, 1);\n\t    child.parent = null;\n\t\n\t    if (storage) {\n\t      storage.delFromStorage(child);\n\t\n\t      if (child instanceof Group) {\n\t        child.delChildrenFromStorage(storage);\n\t      }\n\t    }\n\t\n\t    zr && zr.refresh();\n\t    return this;\n\t  },\n\t\n\t  /**\n\t   * 移除所有子节点\n\t   */\n\t  removeAll: function () {\n\t    var children = this._children;\n\t    var storage = this.__storage;\n\t    var child;\n\t    var i;\n\t\n\t    for (i = 0; i < children.length; i++) {\n\t      child = children[i];\n\t\n\t      if (storage) {\n\t        storage.delFromStorage(child);\n\t\n\t        if (child instanceof Group) {\n\t          child.delChildrenFromStorage(storage);\n\t        }\n\t      }\n\t\n\t      child.parent = null;\n\t    }\n\t\n\t    children.length = 0;\n\t    return this;\n\t  },\n\t\n\t  /**\n\t   * 遍历所有子节点\n\t   * @param  {Function} cb\n\t   * @param  {}   context\n\t   */\n\t  eachChild: function (cb, context) {\n\t    var children = this._children;\n\t\n\t    for (var i = 0; i < children.length; i++) {\n\t      var child = children[i];\n\t      cb.call(context, child, i);\n\t    }\n\t\n\t    return this;\n\t  },\n\t\n\t  /**\n\t   * 深度优先遍历所有子孙节点\n\t   * @param  {Function} cb\n\t   * @param  {}   context\n\t   */\n\t  traverse: function (cb, context) {\n\t    for (var i = 0; i < this._children.length; i++) {\n\t      var child = this._children[i];\n\t      cb.call(context, child);\n\t\n\t      if (child.type === 'group') {\n\t        child.traverse(cb, context);\n\t      }\n\t    }\n\t\n\t    return this;\n\t  },\n\t  addChildrenToStorage: function (storage) {\n\t    for (var i = 0; i < this._children.length; i++) {\n\t      var child = this._children[i];\n\t      storage.addToStorage(child);\n\t\n\t      if (child instanceof Group) {\n\t        child.addChildrenToStorage(storage);\n\t      }\n\t    }\n\t  },\n\t  delChildrenFromStorage: function (storage) {\n\t    for (var i = 0; i < this._children.length; i++) {\n\t      var child = this._children[i];\n\t      storage.delFromStorage(child);\n\t\n\t      if (child instanceof Group) {\n\t        child.delChildrenFromStorage(storage);\n\t      }\n\t    }\n\t  },\n\t  dirty: function () {\n\t    this.__dirty = true;\n\t    this.__zr && this.__zr.refresh();\n\t    return this;\n\t  },\n\t\n\t  /**\n\t   * @return {module:zrender/core/BoundingRect}\n\t   */\n\t  getBoundingRect: function (includeChildren) {\n\t    // TODO Caching\n\t    var rect = null;\n\t    var tmpRect = new BoundingRect(0, 0, 0, 0);\n\t    var children = includeChildren || this._children;\n\t    var tmpMat = [];\n\t\n\t    for (var i = 0; i < children.length; i++) {\n\t      var child = children[i];\n\t\n\t      if (child.ignore || child.invisible) {\n\t        continue;\n\t      }\n\t\n\t      var childRect = child.getBoundingRect();\n\t      var transform = child.getLocalTransform(tmpMat); // TODO\n\t      // The boundingRect cacluated by transforming original\n\t      // rect may be bigger than the actual bundingRect when rotation\n\t      // is used. (Consider a circle rotated aginst its center, where\n\t      // the actual boundingRect should be the same as that not be\n\t      // rotated.) But we can not find better approach to calculate\n\t      // actual boundingRect yet, considering performance.\n\t\n\t      if (transform) {\n\t        tmpRect.copy(childRect);\n\t        tmpRect.applyTransform(transform);\n\t        rect = rect || tmpRect.clone();\n\t        rect.union(tmpRect);\n\t      } else {\n\t        rect = rect || childRect.clone();\n\t        rect.union(childRect);\n\t      }\n\t    }\n\t\n\t    return rect || tmpRect;\n\t  }\n\t};\n\tzrUtil.inherits(Group, Element);\n\tvar _default = Group;\n\tmodule.exports = _default;\n\n/***/ },\n/* 45 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar vec2 = __webpack_require__(3);\n\t\n\tvar curve = __webpack_require__(5);\n\t\n\t/**\n\t * @author Yi Shen(https://github.com/pissang)\n\t */\n\tvar mathMin = Math.min;\n\tvar mathMax = Math.max;\n\tvar mathSin = Math.sin;\n\tvar mathCos = Math.cos;\n\tvar PI2 = Math.PI * 2;\n\tvar start = vec2.create();\n\tvar end = vec2.create();\n\tvar extremity = vec2.create();\n\t/**\n\t * 从顶点数组中计算出最小包围盒，写入`min`和`max`中\n\t * @module zrender/core/bbox\n\t * @param {Array<Object>} points 顶点数组\n\t * @param {number} min\n\t * @param {number} max\n\t */\n\t\n\tfunction fromPoints(points, min, max) {\n\t  if (points.length === 0) {\n\t    return;\n\t  }\n\t\n\t  var p = points[0];\n\t  var left = p[0];\n\t  var right = p[0];\n\t  var top = p[1];\n\t  var bottom = p[1];\n\t  var i;\n\t\n\t  for (i = 1; i < points.length; i++) {\n\t    p = points[i];\n\t    left = mathMin(left, p[0]);\n\t    right = mathMax(right, p[0]);\n\t    top = mathMin(top, p[1]);\n\t    bottom = mathMax(bottom, p[1]);\n\t  }\n\t\n\t  min[0] = left;\n\t  min[1] = top;\n\t  max[0] = right;\n\t  max[1] = bottom;\n\t}\n\t/**\n\t * @memberOf module:zrender/core/bbox\n\t * @param {number} x0\n\t * @param {number} y0\n\t * @param {number} x1\n\t * @param {number} y1\n\t * @param {Array.<number>} min\n\t * @param {Array.<number>} max\n\t */\n\t\n\t\n\tfunction fromLine(x0, y0, x1, y1, min, max) {\n\t  min[0] = mathMin(x0, x1);\n\t  min[1] = mathMin(y0, y1);\n\t  max[0] = mathMax(x0, x1);\n\t  max[1] = mathMax(y0, y1);\n\t}\n\t\n\tvar xDim = [];\n\tvar yDim = [];\n\t/**\n\t * 从三阶贝塞尔曲线(p0, p1, p2, p3)中计算出最小包围盒，写入`min`和`max`中\n\t * @memberOf module:zrender/core/bbox\n\t * @param {number} x0\n\t * @param {number} y0\n\t * @param {number} x1\n\t * @param {number} y1\n\t * @param {number} x2\n\t * @param {number} y2\n\t * @param {number} x3\n\t * @param {number} y3\n\t * @param {Array.<number>} min\n\t * @param {Array.<number>} max\n\t */\n\t\n\tfunction fromCubic(x0, y0, x1, y1, x2, y2, x3, y3, min, max) {\n\t  var cubicExtrema = curve.cubicExtrema;\n\t  var cubicAt = curve.cubicAt;\n\t  var i;\n\t  var n = cubicExtrema(x0, x1, x2, x3, xDim);\n\t  min[0] = Infinity;\n\t  min[1] = Infinity;\n\t  max[0] = -Infinity;\n\t  max[1] = -Infinity;\n\t\n\t  for (i = 0; i < n; i++) {\n\t    var x = cubicAt(x0, x1, x2, x3, xDim[i]);\n\t    min[0] = mathMin(x, min[0]);\n\t    max[0] = mathMax(x, max[0]);\n\t  }\n\t\n\t  n = cubicExtrema(y0, y1, y2, y3, yDim);\n\t\n\t  for (i = 0; i < n; i++) {\n\t    var y = cubicAt(y0, y1, y2, y3, yDim[i]);\n\t    min[1] = mathMin(y, min[1]);\n\t    max[1] = mathMax(y, max[1]);\n\t  }\n\t\n\t  min[0] = mathMin(x0, min[0]);\n\t  max[0] = mathMax(x0, max[0]);\n\t  min[0] = mathMin(x3, min[0]);\n\t  max[0] = mathMax(x3, max[0]);\n\t  min[1] = mathMin(y0, min[1]);\n\t  max[1] = mathMax(y0, max[1]);\n\t  min[1] = mathMin(y3, min[1]);\n\t  max[1] = mathMax(y3, max[1]);\n\t}\n\t/**\n\t * 从二阶贝塞尔曲线(p0, p1, p2)中计算出最小包围盒，写入`min`和`max`中\n\t * @memberOf module:zrender/core/bbox\n\t * @param {number} x0\n\t * @param {number} y0\n\t * @param {number} x1\n\t * @param {number} y1\n\t * @param {number} x2\n\t * @param {number} y2\n\t * @param {Array.<number>} min\n\t * @param {Array.<number>} max\n\t */\n\t\n\t\n\tfunction fromQuadratic(x0, y0, x1, y1, x2, y2, min, max) {\n\t  var quadraticExtremum = curve.quadraticExtremum;\n\t  var quadraticAt = curve.quadraticAt; // Find extremities, where derivative in x dim or y dim is zero\n\t\n\t  var tx = mathMax(mathMin(quadraticExtremum(x0, x1, x2), 1), 0);\n\t  var ty = mathMax(mathMin(quadraticExtremum(y0, y1, y2), 1), 0);\n\t  var x = quadraticAt(x0, x1, x2, tx);\n\t  var y = quadraticAt(y0, y1, y2, ty);\n\t  min[0] = mathMin(x0, x2, x);\n\t  min[1] = mathMin(y0, y2, y);\n\t  max[0] = mathMax(x0, x2, x);\n\t  max[1] = mathMax(y0, y2, y);\n\t}\n\t/**\n\t * 从圆弧中计算出最小包围盒，写入`min`和`max`中\n\t * @method\n\t * @memberOf module:zrender/core/bbox\n\t * @param {number} x\n\t * @param {number} y\n\t * @param {number} rx\n\t * @param {number} ry\n\t * @param {number} startAngle\n\t * @param {number} endAngle\n\t * @param {number} anticlockwise\n\t * @param {Array.<number>} min\n\t * @param {Array.<number>} max\n\t */\n\t\n\t\n\tfunction fromArc(x, y, rx, ry, startAngle, endAngle, anticlockwise, min, max) {\n\t  var vec2Min = vec2.min;\n\t  var vec2Max = vec2.max;\n\t  var diff = Math.abs(startAngle - endAngle);\n\t\n\t  if (diff % PI2 < 1e-4 && diff > 1e-4) {\n\t    // Is a circle\n\t    min[0] = x - rx;\n\t    min[1] = y - ry;\n\t    max[0] = x + rx;\n\t    max[1] = y + ry;\n\t    return;\n\t  }\n\t\n\t  start[0] = mathCos(startAngle) * rx + x;\n\t  start[1] = mathSin(startAngle) * ry + y;\n\t  end[0] = mathCos(endAngle) * rx + x;\n\t  end[1] = mathSin(endAngle) * ry + y;\n\t  vec2Min(min, start, end);\n\t  vec2Max(max, start, end); // Thresh to [0, Math.PI * 2]\n\t\n\t  startAngle = startAngle % PI2;\n\t\n\t  if (startAngle < 0) {\n\t    startAngle = startAngle + PI2;\n\t  }\n\t\n\t  endAngle = endAngle % PI2;\n\t\n\t  if (endAngle < 0) {\n\t    endAngle = endAngle + PI2;\n\t  }\n\t\n\t  if (startAngle > endAngle && !anticlockwise) {\n\t    endAngle += PI2;\n\t  } else if (startAngle < endAngle && anticlockwise) {\n\t    startAngle += PI2;\n\t  }\n\t\n\t  if (anticlockwise) {\n\t    var tmp = endAngle;\n\t    endAngle = startAngle;\n\t    startAngle = tmp;\n\t  } // var number = 0;\n\t  // var step = (anticlockwise ? -Math.PI : Math.PI) / 2;\n\t\n\t\n\t  for (var angle = 0; angle < endAngle; angle += Math.PI / 2) {\n\t    if (angle > startAngle) {\n\t      extremity[0] = mathCos(angle) * rx + x;\n\t      extremity[1] = mathSin(angle) * ry + y;\n\t      vec2Min(min, extremity, min);\n\t      vec2Max(max, extremity, max);\n\t    }\n\t  }\n\t}\n\t\n\texports.fromPoints = fromPoints;\n\texports.fromLine = fromLine;\n\texports.fromCubic = fromCubic;\n\texports.fromQuadratic = fromQuadratic;\n\texports.fromArc = fromArc;\n\n/***/ },\n/* 46 */\n/***/ function(module, exports) {\n\n\t/**\n\t * echarts设备环境识别\n\t *\n\t * @desc echarts基于Canvas，纯Javascript图表库，提供直观，生动，可交互，可个性化定制的数据统计图表。\n\t * @author firede[firede@firede.us]\n\t * @desc thanks zepto.\n\t */\n\tvar env = {};\n\t\n\tif (typeof wx !== 'undefined') {\n\t  // In Weixin Application\n\t  env = {\n\t    browser: {},\n\t    os: {},\n\t    node: false,\n\t    wxa: true,\n\t    // Weixin Application\n\t    canvasSupported: true,\n\t    svgSupported: false,\n\t    touchEventsSupported: true\n\t  };\n\t} else if (typeof document === 'undefined' && typeof self !== 'undefined') {\n\t  // In worker\n\t  env = {\n\t    browser: {},\n\t    os: {},\n\t    node: false,\n\t    worker: true,\n\t    canvasSupported: true\n\t  };\n\t} else if (typeof navigator === 'undefined') {\n\t  // In node\n\t  env = {\n\t    browser: {},\n\t    os: {},\n\t    node: true,\n\t    worker: false,\n\t    // Assume canvas is supported\n\t    canvasSupported: true,\n\t    svgSupported: true\n\t  };\n\t} else {\n\t  env = detect(navigator.userAgent);\n\t}\n\t\n\tvar _default = env; // Zepto.js\n\t// (c) 2010-2013 Thomas Fuchs\n\t// Zepto.js may be freely distributed under the MIT license.\n\t\n\tfunction detect(ua) {\n\t  var os = {};\n\t  var browser = {}; // var webkit = ua.match(/Web[kK]it[\\/]{0,1}([\\d.]+)/);\n\t  // var android = ua.match(/(Android);?[\\s\\/]+([\\d.]+)?/);\n\t  // var ipad = ua.match(/(iPad).*OS\\s([\\d_]+)/);\n\t  // var ipod = ua.match(/(iPod)(.*OS\\s([\\d_]+))?/);\n\t  // var iphone = !ipad && ua.match(/(iPhone\\sOS)\\s([\\d_]+)/);\n\t  // var webos = ua.match(/(webOS|hpwOS)[\\s\\/]([\\d.]+)/);\n\t  // var touchpad = webos && ua.match(/TouchPad/);\n\t  // var kindle = ua.match(/Kindle\\/([\\d.]+)/);\n\t  // var silk = ua.match(/Silk\\/([\\d._]+)/);\n\t  // var blackberry = ua.match(/(BlackBerry).*Version\\/([\\d.]+)/);\n\t  // var bb10 = ua.match(/(BB10).*Version\\/([\\d.]+)/);\n\t  // var rimtabletos = ua.match(/(RIM\\sTablet\\sOS)\\s([\\d.]+)/);\n\t  // var playbook = ua.match(/PlayBook/);\n\t  // var chrome = ua.match(/Chrome\\/([\\d.]+)/) || ua.match(/CriOS\\/([\\d.]+)/);\n\t\n\t  var firefox = ua.match(/Firefox\\/([\\d.]+)/); // var safari = webkit && ua.match(/Mobile\\//) && !chrome;\n\t  // var webview = ua.match(/(iPhone|iPod|iPad).*AppleWebKit(?!.*Safari)/) && !chrome;\n\t\n\t  var ie = ua.match(/MSIE\\s([\\d.]+)/) // IE 11 Trident/7.0; rv:11.0\n\t  || ua.match(/Trident\\/.+?rv:(([\\d.]+))/);\n\t  var edge = ua.match(/Edge\\/([\\d.]+)/); // IE 12 and 12+\n\t\n\t  var weChat = /micromessenger/i.test(ua); // Todo: clean this up with a better OS/browser seperation:\n\t  // - discern (more) between multiple browsers on android\n\t  // - decide if kindle fire in silk mode is android or not\n\t  // - Firefox on Android doesn't specify the Android version\n\t  // - possibly devide in os, device and browser hashes\n\t  // if (browser.webkit = !!webkit) browser.version = webkit[1];\n\t  // if (android) os.android = true, os.version = android[2];\n\t  // if (iphone && !ipod) os.ios = os.iphone = true, os.version = iphone[2].replace(/_/g, '.');\n\t  // if (ipad) os.ios = os.ipad = true, os.version = ipad[2].replace(/_/g, '.');\n\t  // if (ipod) os.ios = os.ipod = true, os.version = ipod[3] ? ipod[3].replace(/_/g, '.') : null;\n\t  // if (webos) os.webos = true, os.version = webos[2];\n\t  // if (touchpad) os.touchpad = true;\n\t  // if (blackberry) os.blackberry = true, os.version = blackberry[2];\n\t  // if (bb10) os.bb10 = true, os.version = bb10[2];\n\t  // if (rimtabletos) os.rimtabletos = true, os.version = rimtabletos[2];\n\t  // if (playbook) browser.playbook = true;\n\t  // if (kindle) os.kindle = true, os.version = kindle[1];\n\t  // if (silk) browser.silk = true, browser.version = silk[1];\n\t  // if (!silk && os.android && ua.match(/Kindle Fire/)) browser.silk = true;\n\t  // if (chrome) browser.chrome = true, browser.version = chrome[1];\n\t\n\t  if (firefox) {\n\t    browser.firefox = true;\n\t    browser.version = firefox[1];\n\t  } // if (safari && (ua.match(/Safari/) || !!os.ios)) browser.safari = true;\n\t  // if (webview) browser.webview = true;\n\t\n\t\n\t  if (ie) {\n\t    browser.ie = true;\n\t    browser.version = ie[1];\n\t  }\n\t\n\t  if (edge) {\n\t    browser.edge = true;\n\t    browser.version = edge[1];\n\t  } // It is difficult to detect WeChat in Win Phone precisely, because ua can\n\t  // not be set on win phone. So we do not consider Win Phone.\n\t\n\t\n\t  if (weChat) {\n\t    browser.weChat = true;\n\t  } // os.tablet = !!(ipad || playbook || (android && !ua.match(/Mobile/)) ||\n\t  //     (firefox && ua.match(/Tablet/)) || (ie && !ua.match(/Phone/) && ua.match(/Touch/)));\n\t  // os.phone  = !!(!os.tablet && !os.ipod && (android || iphone || webos ||\n\t  //     (chrome && ua.match(/Android/)) || (chrome && ua.match(/CriOS\\/([\\d.]+)/)) ||\n\t  //     (firefox && ua.match(/Mobile/)) || (ie && ua.match(/Touch/))));\n\t\n\t\n\t  return {\n\t    browser: browser,\n\t    os: os,\n\t    node: false,\n\t    // 原生canvas支持，改极端点了\n\t    // canvasSupported : !(browser.ie && parseFloat(browser.version) < 9)\n\t    canvasSupported: !!document.createElement('canvas').getContext,\n\t    svgSupported: typeof SVGRect !== 'undefined',\n\t    // works on most browsers\n\t    // IE10/11 does not support touch event, and MS Edge supports them but not by\n\t    // default, so we dont check navigator.maxTouchPoints for them here.\n\t    touchEventsSupported: 'ontouchstart' in window && !browser.ie && !browser.edge,\n\t    // <http://caniuse.com/#search=pointer%20event>.\n\t    pointerEventsSupported: 'onpointerdown' in window // Firefox supports pointer but not by default, only MS browsers are reliable on pointer\n\t    // events currently. So we dont use that on other browsers unless tested sufficiently.\n\t    // Although IE 10 supports pointer event, it use old style and is different from the\n\t    // standard. So we exclude that. (IE 10 is hardly used on touch device)\n\t    && (browser.edge || browser.ie && browser.version >= 11)\n\t  };\n\t}\n\t\n\tmodule.exports = _default;\n\n/***/ },\n/* 47 */\n/***/ function(module, exports) {\n\n\t/**\n\t * zrender: 生成唯一id\n\t *\n\t * @author errorrik (errorrik@gmail.com)\n\t */\n\tvar idStart = 0x0907;\n\t\n\tfunction _default() {\n\t  return idStart++;\n\t}\n\t\n\tmodule.exports = _default;\n\n/***/ },\n/* 48 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar _config = __webpack_require__(16);\n\t\n\tvar debugMode = _config.debugMode;\n\t\n\tvar log = function () {};\n\t\n\tif (debugMode === 1) {\n\t  log = function () {\n\t    for (var k in arguments) {\n\t      throw new Error(arguments[k]);\n\t    }\n\t  };\n\t} else if (debugMode > 1) {\n\t  log = function () {\n\t    for (var k in arguments) {\n\t      console.log(arguments[k]);\n\t    }\n\t  };\n\t}\n\t\n\tvar _default = log;\n\tmodule.exports = _default;\n\n/***/ },\n/* 49 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar Path = __webpack_require__(2);\n\t\n\t// CompoundPath to improve performance\n\tvar _default = Path.extend({\n\t  type: 'compound',\n\t  shape: {\n\t    paths: null\n\t  },\n\t  _updatePathDirty: function () {\n\t    var dirtyPath = this.__dirtyPath;\n\t    var paths = this.shape.paths;\n\t\n\t    for (var i = 0; i < paths.length; i++) {\n\t      // Mark as dirty if any subpath is dirty\n\t      dirtyPath = dirtyPath || paths[i].__dirtyPath;\n\t    }\n\t\n\t    this.__dirtyPath = dirtyPath;\n\t    this.__dirty = this.__dirty || dirtyPath;\n\t  },\n\t  beforeBrush: function () {\n\t    this._updatePathDirty();\n\t\n\t    var paths = this.shape.paths || [];\n\t    var scale = this.getGlobalScale(); // Update path scale\n\t\n\t    for (var i = 0; i < paths.length; i++) {\n\t      if (!paths[i].path) {\n\t        paths[i].createPathProxy();\n\t      }\n\t\n\t      paths[i].path.setScale(scale[0], scale[1]);\n\t    }\n\t  },\n\t  buildPath: function (ctx, shape) {\n\t    var paths = shape.paths || [];\n\t\n\t    for (var i = 0; i < paths.length; i++) {\n\t      paths[i].buildPath(ctx, paths[i].shape, true);\n\t    }\n\t  },\n\t  afterBrush: function () {\n\t    var paths = this.shape.paths || [];\n\t\n\t    for (var i = 0; i < paths.length; i++) {\n\t      paths[i].__dirtyPath = false;\n\t    }\n\t  },\n\t  getBoundingRect: function () {\n\t    this._updatePathDirty();\n\t\n\t    return Path.prototype.getBoundingRect.call(this);\n\t  }\n\t});\n\t\n\tmodule.exports = _default;\n\n/***/ },\n/* 50 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar Displayable = __webpack_require__(8);\n\t\n\tvar BoundingRect = __webpack_require__(4);\n\t\n\tvar zrUtil = __webpack_require__(1);\n\t\n\tvar imageHelper = __webpack_require__(11);\n\t\n\t/**\n\t * @alias zrender/graphic/Image\n\t * @extends module:zrender/graphic/Displayable\n\t * @constructor\n\t * @param {Object} opts\n\t */\n\tfunction ZImage(opts) {\n\t  Displayable.call(this, opts);\n\t}\n\t\n\tZImage.prototype = {\n\t  constructor: ZImage,\n\t  type: 'image',\n\t  brush: function (ctx, prevEl) {\n\t    var style = this.style;\n\t    var src = style.image; // Must bind each time\n\t\n\t    style.bind(ctx, this, prevEl);\n\t    var image = this._image = imageHelper.createOrUpdateImage(src, this._image, this, this.onload);\n\t\n\t    if (!image || !imageHelper.isImageReady(image)) {\n\t      return;\n\t    } // 图片已经加载完成\n\t    // if (image.nodeName.toUpperCase() == 'IMG') {\n\t    //     if (!image.complete) {\n\t    //         return;\n\t    //     }\n\t    // }\n\t    // Else is canvas\n\t\n\t\n\t    var x = style.x || 0;\n\t    var y = style.y || 0;\n\t    var width = style.width;\n\t    var height = style.height;\n\t    var aspect = image.width / image.height;\n\t\n\t    if (width == null && height != null) {\n\t      // Keep image/height ratio\n\t      width = height * aspect;\n\t    } else if (height == null && width != null) {\n\t      height = width / aspect;\n\t    } else if (width == null && height == null) {\n\t      width = image.width;\n\t      height = image.height;\n\t    } // 设置transform\n\t\n\t\n\t    this.setTransform(ctx);\n\t\n\t    if (style.sWidth && style.sHeight) {\n\t      var sx = style.sx || 0;\n\t      var sy = style.sy || 0;\n\t      ctx.drawImage(image, sx, sy, style.sWidth, style.sHeight, x, y, width, height);\n\t    } else if (style.sx && style.sy) {\n\t      var sx = style.sx;\n\t      var sy = style.sy;\n\t      var sWidth = width - sx;\n\t      var sHeight = height - sy;\n\t      ctx.drawImage(image, sx, sy, sWidth, sHeight, x, y, width, height);\n\t    } else {\n\t      ctx.drawImage(image, x, y, width, height);\n\t    } // Draw rect text\n\t\n\t\n\t    if (style.text != null) {\n\t      // Only restore transform when needs draw text.\n\t      this.restoreTransform(ctx);\n\t      this.drawRectText(ctx, this.getBoundingRect());\n\t    }\n\t  },\n\t  getBoundingRect: function () {\n\t    var style = this.style;\n\t\n\t    if (!this._rect) {\n\t      this._rect = new BoundingRect(style.x || 0, style.y || 0, style.width || 0, style.height || 0);\n\t    }\n\t\n\t    return this._rect;\n\t  }\n\t};\n\tzrUtil.inherits(ZImage, Displayable);\n\tvar _default = ZImage;\n\tmodule.exports = _default;\n\n/***/ },\n/* 51 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar _util = __webpack_require__(1);\n\t\n\tvar inherits = _util.inherits;\n\t\n\tvar Displayble = __webpack_require__(8);\n\t\n\tvar BoundingRect = __webpack_require__(4);\n\t\n\t/**\n\t * Displayable for incremental rendering. It will be rendered in a separate layer\n\t * IncrementalDisplay have too main methods. `clearDisplayables` and `addDisplayables`\n\t * addDisplayables will render the added displayables incremetally.\n\t *\n\t * It use a not clearFlag to tell the painter don't clear the layer if it's the first element.\n\t */\n\t// TODO Style override ?\n\tfunction IncrementalDisplayble(opts) {\n\t  Displayble.call(this, opts);\n\t  this._displayables = [];\n\t  this._temporaryDisplayables = [];\n\t  this._cursor = 0;\n\t  this.notClear = true;\n\t}\n\t\n\tIncrementalDisplayble.prototype.incremental = true;\n\t\n\tIncrementalDisplayble.prototype.clearDisplaybles = function () {\n\t  this._displayables = [];\n\t  this._temporaryDisplayables = [];\n\t  this._cursor = 0;\n\t  this.dirty();\n\t  this.notClear = false;\n\t};\n\t\n\tIncrementalDisplayble.prototype.addDisplayable = function (displayable, notPersistent) {\n\t  if (notPersistent) {\n\t    this._temporaryDisplayables.push(displayable);\n\t  } else {\n\t    this._displayables.push(displayable);\n\t  }\n\t\n\t  this.dirty();\n\t};\n\t\n\tIncrementalDisplayble.prototype.addDisplayables = function (displayables, notPersistent) {\n\t  notPersistent = notPersistent || false;\n\t\n\t  for (var i = 0; i < displayables.length; i++) {\n\t    this.addDisplayable(displayables[i], notPersistent);\n\t  }\n\t};\n\t\n\tIncrementalDisplayble.prototype.eachPendingDisplayable = function (cb) {\n\t  for (var i = this._cursor; i < this._displayables.length; i++) {\n\t    cb && cb(this._displayables[i]);\n\t  }\n\t\n\t  for (var i = 0; i < this._temporaryDisplayables.length; i++) {\n\t    cb && cb(this._temporaryDisplayables[i]);\n\t  }\n\t};\n\t\n\tIncrementalDisplayble.prototype.update = function () {\n\t  this.updateTransform();\n\t\n\t  for (var i = this._cursor; i < this._displayables.length; i++) {\n\t    var displayable = this._displayables[i]; // PENDING\n\t\n\t    displayable.parent = this;\n\t    displayable.update();\n\t    displayable.parent = null;\n\t  }\n\t\n\t  for (var i = 0; i < this._temporaryDisplayables.length; i++) {\n\t    var displayable = this._temporaryDisplayables[i]; // PENDING\n\t\n\t    displayable.parent = this;\n\t    displayable.update();\n\t    displayable.parent = null;\n\t  }\n\t};\n\t\n\tIncrementalDisplayble.prototype.brush = function (ctx, prevEl) {\n\t  // Render persistant displayables.\n\t  for (var i = this._cursor; i < this._displayables.length; i++) {\n\t    var displayable = this._temporaryDisplayables[i];\n\t    displayable.beforeBrush && displayable.beforeBrush(ctx);\n\t    displayable.brush(ctx, i === this._cursor ? null : this._displayables[i - 1]);\n\t    displayable.afterBrush && displayable.afterBrush(ctx);\n\t  }\n\t\n\t  this._cursor = i; // Render temporary displayables.\n\t\n\t  for (var i = 0; i < this._temporaryDisplayables.length; i++) {\n\t    var displayable = this._temporaryDisplayables[i];\n\t    displayable.beforeBrush && displayable.beforeBrush(ctx);\n\t    displayable.brush(ctx, i === 0 ? null : this._temporaryDisplayables[i - 1]);\n\t    displayable.afterBrush && displayable.afterBrush(ctx);\n\t  }\n\t\n\t  this._temporaryDisplayables = [];\n\t  this.notClear = true;\n\t};\n\t\n\tvar m = [];\n\t\n\tIncrementalDisplayble.prototype.getBoundingRect = function () {\n\t  if (!this._rect) {\n\t    var rect = new BoundingRect(Infinity, Infinity, -Infinity, -Infinity);\n\t\n\t    for (var i = 0; i < this._displayables.length; i++) {\n\t      var displayable = this._displayables[i];\n\t      var childRect = displayable.getBoundingRect().clone();\n\t\n\t      if (displayable.needLocalTransform()) {\n\t        childRect.applyTransform(displayable.getLocalTransform(m));\n\t      }\n\t\n\t      rect.union(childRect);\n\t    }\n\t\n\t    this._rect = rect;\n\t  }\n\t\n\t  return this._rect;\n\t};\n\t\n\tIncrementalDisplayble.prototype.contain = function (x, y) {\n\t  var localPos = this.transformCoordToLocal(x, y);\n\t  var rect = this.getBoundingRect();\n\t\n\t  if (rect.contain(localPos[0], localPos[1])) {\n\t    for (var i = 0; i < this._displayables.length; i++) {\n\t      var displayable = this._displayables[i];\n\t\n\t      if (displayable.contain(x, y)) {\n\t        return true;\n\t      }\n\t    }\n\t  }\n\t\n\t  return false;\n\t};\n\t\n\tinherits(IncrementalDisplayble, Displayble);\n\tvar _default = IncrementalDisplayble;\n\tmodule.exports = _default;\n\n/***/ },\n/* 52 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar zrUtil = __webpack_require__(1);\n\t\n\tvar Gradient = __webpack_require__(20);\n\t\n\t/**\n\t * x, y, x2, y2 are all percent from 0 to 1\n\t * @param {number} [x=0]\n\t * @param {number} [y=0]\n\t * @param {number} [x2=1]\n\t * @param {number} [y2=0]\n\t * @param {Array.<Object>} colorStops\n\t * @param {boolean} [globalCoord=false]\n\t */\n\tvar LinearGradient = function (x, y, x2, y2, colorStops, globalCoord) {\n\t  // Should do nothing more in this constructor. Because gradient can be\n\t  // declard by `color: {type: 'linear', colorStops: ...}`, where\n\t  // this constructor will not be called.\n\t  this.x = x == null ? 0 : x;\n\t  this.y = y == null ? 0 : y;\n\t  this.x2 = x2 == null ? 1 : x2;\n\t  this.y2 = y2 == null ? 0 : y2; // Can be cloned\n\t\n\t  this.type = 'linear'; // If use global coord\n\t\n\t  this.global = globalCoord || false;\n\t  Gradient.call(this, colorStops);\n\t};\n\t\n\tLinearGradient.prototype = {\n\t  constructor: LinearGradient\n\t};\n\tzrUtil.inherits(LinearGradient, Gradient);\n\tvar _default = LinearGradient;\n\tmodule.exports = _default;\n\n/***/ },\n/* 53 */\n/***/ function(module, exports) {\n\n\tvar Pattern = function (image, repeat) {\n\t  // Should do nothing more in this constructor. Because gradient can be\n\t  // declard by `color: {image: ...}`, where this constructor will not be called.\n\t  this.image = image;\n\t  this.repeat = repeat; // Can be cloned\n\t\n\t  this.type = 'pattern';\n\t};\n\t\n\tPattern.prototype.getCanvasPattern = function (ctx) {\n\t  return ctx.createPattern(this.image, this.repeat || 'repeat');\n\t};\n\t\n\tvar _default = Pattern;\n\tmodule.exports = _default;\n\n/***/ },\n/* 54 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar zrUtil = __webpack_require__(1);\n\t\n\tvar Gradient = __webpack_require__(20);\n\t\n\t/**\n\t * x, y, r are all percent from 0 to 1\n\t * @param {number} [x=0.5]\n\t * @param {number} [y=0.5]\n\t * @param {number} [r=0.5]\n\t * @param {Array.<Object>} [colorStops]\n\t * @param {boolean} [globalCoord=false]\n\t */\n\tvar RadialGradient = function (x, y, r, colorStops, globalCoord) {\n\t  // Should do nothing more in this constructor. Because gradient can be\n\t  // declard by `color: {type: 'radial', colorStops: ...}`, where\n\t  // this constructor will not be called.\n\t  this.x = x == null ? 0.5 : x;\n\t  this.y = y == null ? 0.5 : y;\n\t  this.r = r == null ? 0.5 : r; // Can be cloned\n\t\n\t  this.type = 'radial'; // If use global coord\n\t\n\t  this.global = globalCoord || false;\n\t  Gradient.call(this, colorStops);\n\t};\n\t\n\tRadialGradient.prototype = {\n\t  constructor: RadialGradient\n\t};\n\tzrUtil.inherits(RadialGradient, Gradient);\n\tvar _default = RadialGradient;\n\tmodule.exports = _default;\n\n/***/ },\n/* 55 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar fixShadow = __webpack_require__(21);\n\t\n\tvar 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\t// var LINE_PROPS = STYLE_COMMON_PROPS.slice(4);\n\t\n\tvar Style = function (opts, host) {\n\t  this.extendFrom(opts, false);\n\t  this.host = host;\n\t};\n\t\n\tfunction createLinearGradient(ctx, obj, rect) {\n\t  var x = obj.x == null ? 0 : obj.x;\n\t  var x2 = obj.x2 == null ? 1 : obj.x2;\n\t  var y = obj.y == null ? 0 : obj.y;\n\t  var y2 = obj.y2 == null ? 0 : obj.y2;\n\t\n\t  if (!obj.global) {\n\t    x = x * rect.width + rect.x;\n\t    x2 = x2 * rect.width + rect.x;\n\t    y = y * rect.height + rect.y;\n\t    y2 = y2 * rect.height + rect.y;\n\t  }\n\t\n\t  var canvasGradient = ctx.createLinearGradient(x, y, x2, y2);\n\t  return canvasGradient;\n\t}\n\t\n\tfunction createRadialGradient(ctx, obj, rect) {\n\t  var width = rect.width;\n\t  var height = rect.height;\n\t  var min = Math.min(width, height);\n\t  var x = obj.x == null ? 0.5 : obj.x;\n\t  var y = obj.y == null ? 0.5 : obj.y;\n\t  var r = obj.r == null ? 0.5 : obj.r;\n\t\n\t  if (!obj.global) {\n\t    x = x * width + rect.x;\n\t    y = y * height + rect.y;\n\t    r = r * min;\n\t  }\n\t\n\t  var canvasGradient = ctx.createRadialGradient(x, y, 0, x, y, r);\n\t  return canvasGradient;\n\t}\n\t\n\tStyle.prototype = {\n\t  constructor: Style,\n\t\n\t  /**\n\t   * @type {module:zrender/graphic/Displayable}\n\t   */\n\t  host: null,\n\t\n\t  /**\n\t   * @type {string}\n\t   */\n\t  fill: '#000',\n\t\n\t  /**\n\t   * @type {string}\n\t   */\n\t  stroke: null,\n\t\n\t  /**\n\t   * @type {number}\n\t   */\n\t  opacity: 1,\n\t\n\t  /**\n\t   * @type {Array.<number>}\n\t   */\n\t  lineDash: null,\n\t\n\t  /**\n\t   * @type {number}\n\t   */\n\t  lineDashOffset: 0,\n\t\n\t  /**\n\t   * @type {number}\n\t   */\n\t  shadowBlur: 0,\n\t\n\t  /**\n\t   * @type {number}\n\t   */\n\t  shadowOffsetX: 0,\n\t\n\t  /**\n\t   * @type {number}\n\t   */\n\t  shadowOffsetY: 0,\n\t\n\t  /**\n\t   * @type {number}\n\t   */\n\t  lineWidth: 1,\n\t\n\t  /**\n\t   * If stroke ignore scale\n\t   * @type {Boolean}\n\t   */\n\t  strokeNoScale: false,\n\t  // Bounding rect text configuration\n\t  // Not affected by element transform\n\t\n\t  /**\n\t   * @type {string}\n\t   */\n\t  text: null,\n\t\n\t  /**\n\t   * If `fontSize` or `fontFamily` exists, `font` will be reset by\n\t   * `fontSize`, `fontStyle`, `fontWeight`, `fontFamily`.\n\t   * So do not visit it directly in upper application (like echarts),\n\t   * but use `contain/text#makeFont` instead.\n\t   * @type {string}\n\t   */\n\t  font: null,\n\t\n\t  /**\n\t   * The same as font. Use font please.\n\t   * @deprecated\n\t   * @type {string}\n\t   */\n\t  textFont: null,\n\t\n\t  /**\n\t   * It helps merging respectively, rather than parsing an entire font string.\n\t   * @type {string}\n\t   */\n\t  fontStyle: null,\n\t\n\t  /**\n\t   * It helps merging respectively, rather than parsing an entire font string.\n\t   * @type {string}\n\t   */\n\t  fontWeight: null,\n\t\n\t  /**\n\t   * It helps merging respectively, rather than parsing an entire font string.\n\t   * Should be 12 but not '12px'.\n\t   * @type {number}\n\t   */\n\t  fontSize: null,\n\t\n\t  /**\n\t   * It helps merging respectively, rather than parsing an entire font string.\n\t   * @type {string}\n\t   */\n\t  fontFamily: null,\n\t\n\t  /**\n\t   * Reserved for special functinality, like 'hr'.\n\t   * @type {string}\n\t   */\n\t  textTag: null,\n\t\n\t  /**\n\t   * @type {string}\n\t   */\n\t  textFill: '#000',\n\t\n\t  /**\n\t   * @type {string}\n\t   */\n\t  textStroke: null,\n\t\n\t  /**\n\t   * @type {number}\n\t   */\n\t  textWidth: null,\n\t\n\t  /**\n\t   * Only for textBackground.\n\t   * @type {number}\n\t   */\n\t  textHeight: null,\n\t\n\t  /**\n\t   * textStroke may be set as some color as a default\n\t   * value in upper applicaion, where the default value\n\t   * of textStrokeWidth should be 0 to make sure that\n\t   * user can choose to do not use text stroke.\n\t   * @type {number}\n\t   */\n\t  textStrokeWidth: 0,\n\t\n\t  /**\n\t   * @type {number}\n\t   */\n\t  textLineHeight: null,\n\t\n\t  /**\n\t   * 'inside', 'left', 'right', 'top', 'bottom'\n\t   * [x, y]\n\t   * Based on x, y of rect.\n\t   * @type {string|Array.<number>}\n\t   * @default 'inside'\n\t   */\n\t  textPosition: 'inside',\n\t\n\t  /**\n\t   * If not specified, use the boundingRect of a `displayable`.\n\t   * @type {Object}\n\t   */\n\t  textRect: null,\n\t\n\t  /**\n\t   * [x, y]\n\t   * @type {Array.<number>}\n\t   */\n\t  textOffset: null,\n\t\n\t  /**\n\t   * @type {string}\n\t   */\n\t  textAlign: null,\n\t\n\t  /**\n\t   * @type {string}\n\t   */\n\t  textVerticalAlign: null,\n\t\n\t  /**\n\t   * @type {number}\n\t   */\n\t  textDistance: 5,\n\t\n\t  /**\n\t   * @type {string}\n\t   */\n\t  textShadowColor: 'transparent',\n\t\n\t  /**\n\t   * @type {number}\n\t   */\n\t  textShadowBlur: 0,\n\t\n\t  /**\n\t   * @type {number}\n\t   */\n\t  textShadowOffsetX: 0,\n\t\n\t  /**\n\t   * @type {number}\n\t   */\n\t  textShadowOffsetY: 0,\n\t\n\t  /**\n\t   * @type {string}\n\t   */\n\t  textBoxShadowColor: 'transparent',\n\t\n\t  /**\n\t   * @type {number}\n\t   */\n\t  textBoxShadowBlur: 0,\n\t\n\t  /**\n\t   * @type {number}\n\t   */\n\t  textBoxShadowOffsetX: 0,\n\t\n\t  /**\n\t   * @type {number}\n\t   */\n\t  textBoxShadowOffsetY: 0,\n\t\n\t  /**\n\t   * Whether transform text.\n\t   * Only useful in Path and Image element\n\t   * @type {boolean}\n\t   */\n\t  transformText: false,\n\t\n\t  /**\n\t   * Text rotate around position of Path or Image\n\t   * Only useful in Path and Image element and transformText is false.\n\t   */\n\t  textRotation: 0,\n\t\n\t  /**\n\t   * Text origin of text rotation, like [10, 40].\n\t   * Based on x, y of rect.\n\t   * Useful in label rotation of circular symbol.\n\t   * By default, this origin is textPosition.\n\t   * Can be 'center'.\n\t   * @type {string|Array.<number>}\n\t   */\n\t  textOrigin: null,\n\t\n\t  /**\n\t   * @type {string}\n\t   */\n\t  textBackgroundColor: null,\n\t\n\t  /**\n\t   * @type {string}\n\t   */\n\t  textBorderColor: null,\n\t\n\t  /**\n\t   * @type {number}\n\t   */\n\t  textBorderWidth: 0,\n\t\n\t  /**\n\t   * @type {number}\n\t   */\n\t  textBorderRadius: 0,\n\t\n\t  /**\n\t   * Can be `2` or `[2, 4]` or `[2, 3, 4, 5]`\n\t   * @type {number|Array.<number>}\n\t   */\n\t  textPadding: null,\n\t\n\t  /**\n\t   * Text styles for rich text.\n\t   * @type {Object}\n\t   */\n\t  rich: null,\n\t\n\t  /**\n\t   * {outerWidth, outerHeight, ellipsis, placeholder}\n\t   * @type {Object}\n\t   */\n\t  truncate: null,\n\t\n\t  /**\n\t   * https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/globalCompositeOperation\n\t   * @type {string}\n\t   */\n\t  blend: null,\n\t\n\t  /**\n\t   * @param {CanvasRenderingContext2D} ctx\n\t   */\n\t  bind: function (ctx, el, prevEl) {\n\t    var style = this;\n\t    var prevStyle = prevEl && prevEl.style;\n\t    var firstDraw = !prevStyle;\n\t\n\t    for (var i = 0; i < STYLE_COMMON_PROPS.length; i++) {\n\t      var prop = STYLE_COMMON_PROPS[i];\n\t      var styleName = prop[0];\n\t\n\t      if (firstDraw || style[styleName] !== prevStyle[styleName]) {\n\t        // FIXME Invalid property value will cause style leak from previous element.\n\t        ctx[styleName] = fixShadow(ctx, styleName, style[styleName] || prop[1]);\n\t      }\n\t    }\n\t\n\t    if (firstDraw || style.fill !== prevStyle.fill) {\n\t      ctx.fillStyle = style.fill;\n\t    }\n\t\n\t    if (firstDraw || style.stroke !== prevStyle.stroke) {\n\t      ctx.strokeStyle = style.stroke;\n\t    }\n\t\n\t    if (firstDraw || style.opacity !== prevStyle.opacity) {\n\t      ctx.globalAlpha = style.opacity == null ? 1 : style.opacity;\n\t    }\n\t\n\t    if (firstDraw || style.blend !== prevStyle.blend) {\n\t      ctx.globalCompositeOperation = style.blend || 'source-over';\n\t    }\n\t\n\t    if (this.hasStroke()) {\n\t      var lineWidth = style.lineWidth;\n\t      ctx.lineWidth = lineWidth / (this.strokeNoScale && el && el.getLineScale ? el.getLineScale() : 1);\n\t    }\n\t  },\n\t  hasFill: function () {\n\t    var fill = this.fill;\n\t    return fill != null && fill !== 'none';\n\t  },\n\t  hasStroke: function () {\n\t    var stroke = this.stroke;\n\t    return stroke != null && stroke !== 'none' && this.lineWidth > 0;\n\t  },\n\t\n\t  /**\n\t   * Extend from other style\n\t   * @param {zrender/graphic/Style} otherStyle\n\t   * @param {boolean} overwrite true: overwrirte any way.\n\t   *                            false: overwrite only when !target.hasOwnProperty\n\t   *                            others: overwrite when property is not null/undefined.\n\t   */\n\t  extendFrom: function (otherStyle, overwrite) {\n\t    if (otherStyle) {\n\t      for (var name in otherStyle) {\n\t        if (otherStyle.hasOwnProperty(name) && (overwrite === true || (overwrite === false ? !this.hasOwnProperty(name) : otherStyle[name] != null))) {\n\t          this[name] = otherStyle[name];\n\t        }\n\t      }\n\t    }\n\t  },\n\t\n\t  /**\n\t   * Batch setting style with a given object\n\t   * @param {Object|string} obj\n\t   * @param {*} [obj]\n\t   */\n\t  set: function (obj, value) {\n\t    if (typeof obj === 'string') {\n\t      this[obj] = value;\n\t    } else {\n\t      this.extendFrom(obj, true);\n\t    }\n\t  },\n\t\n\t  /**\n\t   * Clone\n\t   * @return {zrender/graphic/Style} [description]\n\t   */\n\t  clone: function () {\n\t    var newStyle = new this.constructor();\n\t    newStyle.extendFrom(this, true);\n\t    return newStyle;\n\t  },\n\t  getGradient: function (ctx, obj, rect) {\n\t    var method = obj.type === 'radial' ? createRadialGradient : createLinearGradient;\n\t    var canvasGradient = method(ctx, obj, rect);\n\t    var colorStops = obj.colorStops;\n\t\n\t    for (var i = 0; i < colorStops.length; i++) {\n\t      canvasGradient.addColorStop(colorStops[i].offset, colorStops[i].color);\n\t    }\n\t\n\t    return canvasGradient;\n\t  }\n\t};\n\tvar styleProto = Style.prototype;\n\t\n\tfor (var i = 0; i < STYLE_COMMON_PROPS.length; i++) {\n\t  var prop = STYLE_COMMON_PROPS[i];\n\t\n\t  if (!(prop[0] in styleProto)) {\n\t    styleProto[prop[0]] = prop[1];\n\t  }\n\t} // Provide for others\n\t\n\t\n\tStyle.getGradient = styleProto.getGradient;\n\tvar _default = Style;\n\tmodule.exports = _default;\n\n/***/ },\n/* 56 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar Displayable = __webpack_require__(8);\n\t\n\tvar zrUtil = __webpack_require__(1);\n\t\n\tvar textContain = __webpack_require__(17);\n\t\n\tvar textHelper = __webpack_require__(24);\n\t\n\t/**\n\t * @alias zrender/graphic/Text\n\t * @extends module:zrender/graphic/Displayable\n\t * @constructor\n\t * @param {Object} opts\n\t */\n\tvar Text = function (opts) {\n\t  // jshint ignore:line\n\t  Displayable.call(this, opts);\n\t};\n\t\n\tText.prototype = {\n\t  constructor: Text,\n\t  type: 'text',\n\t  brush: function (ctx, prevEl) {\n\t    var style = this.style; // Optimize, avoid normalize every time.\n\t\n\t    this.__dirty && textHelper.normalizeTextStyle(style, true); // Use props with prefix 'text'.\n\t\n\t    style.fill = style.stroke = style.shadowBlur = style.shadowColor = style.shadowOffsetX = style.shadowOffsetY = null;\n\t    var text = style.text; // Convert to string\n\t\n\t    text != null && (text += ''); // Always bind style\n\t\n\t    style.bind(ctx, this, prevEl);\n\t\n\t    if (!textHelper.needDrawText(text, style)) {\n\t      return;\n\t    }\n\t\n\t    this.setTransform(ctx);\n\t    textHelper.renderText(this, ctx, text, style);\n\t    this.restoreTransform(ctx);\n\t  },\n\t  getBoundingRect: function () {\n\t    var style = this.style; // Optimize, avoid normalize every time.\n\t\n\t    this.__dirty && textHelper.normalizeTextStyle(style, true);\n\t\n\t    if (!this._rect) {\n\t      var text = style.text;\n\t      text != null ? text += '' : text = '';\n\t      var rect = textContain.getBoundingRect(style.text + '', style.font, style.textAlign, style.textVerticalAlign, style.textPadding, style.rich);\n\t      rect.x += style.x || 0;\n\t      rect.y += style.y || 0;\n\t\n\t      if (textHelper.getStroke(style.textStroke, style.textStrokeWidth)) {\n\t        var w = style.textStrokeWidth;\n\t        rect.x -= w / 2;\n\t        rect.y -= w / 2;\n\t        rect.width += w;\n\t        rect.height += w;\n\t      }\n\t\n\t      this._rect = rect;\n\t    }\n\t\n\t    return this._rect;\n\t  }\n\t};\n\tzrUtil.inherits(Text, Displayable);\n\tvar _default = Text;\n\tmodule.exports = _default;\n\n/***/ },\n/* 57 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar env = __webpack_require__(46);\n\t\n\t// Fix weird bug in some version of IE11 (like 11.0.9600.178**),\n\t// where exception \"unexpected call to method or property access\"\n\t// might be thrown when calling ctx.fill or ctx.stroke after a path\n\t// whose area size is zero is drawn and ctx.clip() is called and\n\t// shadowBlur is set. See #4572, #3112, #5777.\n\t// (e.g.,\n\t//  ctx.moveTo(10, 10);\n\t//  ctx.lineTo(20, 10);\n\t//  ctx.closePath();\n\t//  ctx.clip();\n\t//  ctx.shadowBlur = 10;\n\t//  ...\n\t//  ctx.fill();\n\t// )\n\tvar shadowTemp = [['shadowBlur', 0], ['shadowColor', '#000'], ['shadowOffsetX', 0], ['shadowOffsetY', 0]];\n\t\n\tfunction _default(orignalBrush) {\n\t  // version string can be: '11.0'\n\t  return env.browser.ie && env.browser.version >= 11 ? function () {\n\t    var clipPaths = this.__clipPaths;\n\t    var style = this.style;\n\t    var modified;\n\t\n\t    if (clipPaths) {\n\t      for (var i = 0; i < clipPaths.length; i++) {\n\t        var clipPath = clipPaths[i];\n\t        var shape = clipPath && clipPath.shape;\n\t        var type = clipPath && clipPath.type;\n\t\n\t        if (shape && (type === 'sector' && shape.startAngle === shape.endAngle || type === 'rect' && (!shape.width || !shape.height))) {\n\t          for (var j = 0; j < shadowTemp.length; j++) {\n\t            // It is save to put shadowTemp static, because shadowTemp\n\t            // will be all modified each item brush called.\n\t            shadowTemp[j][2] = style[shadowTemp[j][0]];\n\t            style[shadowTemp[j][0]] = shadowTemp[j][1];\n\t          }\n\t\n\t          modified = true;\n\t          break;\n\t        }\n\t      }\n\t    }\n\t\n\t    orignalBrush.apply(this, arguments);\n\t\n\t    if (modified) {\n\t      for (var j = 0; j < shadowTemp.length; j++) {\n\t        style[shadowTemp[j][0]] = shadowTemp[j][2];\n\t      }\n\t    }\n\t  } : orignalBrush;\n\t}\n\t\n\tmodule.exports = _default;\n\n/***/ },\n/* 58 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar _vector = __webpack_require__(3);\n\t\n\tvar v2Min = _vector.min;\n\tvar v2Max = _vector.max;\n\tvar v2Scale = _vector.scale;\n\tvar v2Distance = _vector.distance;\n\tvar v2Add = _vector.add;\n\tvar v2Clone = _vector.clone;\n\tvar v2Sub = _vector.sub;\n\t\n\t/**\n\t * 贝塞尔平滑曲线\n\t * @module zrender/shape/util/smoothBezier\n\t * @author pissang (https://www.github.com/pissang)\n\t *         Kener (@Kener-林峰, kener.linfeng@gmail.com)\n\t *         errorrik (errorrik@gmail.com)\n\t */\n\t\n\t/**\n\t * 贝塞尔平滑曲线\n\t * @alias module:zrender/shape/util/smoothBezier\n\t * @param {Array} points 线段顶点数组\n\t * @param {number} smooth 平滑等级, 0-1\n\t * @param {boolean} isLoop\n\t * @param {Array} constraint 将计算出来的控制点约束在一个包围盒内\n\t *                           比如 [[0, 0], [100, 100]], 这个包围盒会与\n\t *                           整个折线的包围盒做一个并集用来约束控制点。\n\t * @param {Array} 计算出来的控制点数组\n\t */\n\tfunction _default(points, smooth, isLoop, constraint) {\n\t  var cps = [];\n\t  var v = [];\n\t  var v1 = [];\n\t  var v2 = [];\n\t  var prevPoint;\n\t  var nextPoint;\n\t  var min, max;\n\t\n\t  if (constraint) {\n\t    min = [Infinity, Infinity];\n\t    max = [-Infinity, -Infinity];\n\t\n\t    for (var i = 0, len = points.length; i < len; i++) {\n\t      v2Min(min, min, points[i]);\n\t      v2Max(max, max, points[i]);\n\t    } // 与指定的包围盒做并集\n\t\n\t\n\t    v2Min(min, min, constraint[0]);\n\t    v2Max(max, max, constraint[1]);\n\t  }\n\t\n\t  for (var i = 0, len = points.length; i < len; i++) {\n\t    var point = points[i];\n\t\n\t    if (isLoop) {\n\t      prevPoint = points[i ? i - 1 : len - 1];\n\t      nextPoint = points[(i + 1) % len];\n\t    } else {\n\t      if (i === 0 || i === len - 1) {\n\t        cps.push(v2Clone(points[i]));\n\t        continue;\n\t      } else {\n\t        prevPoint = points[i - 1];\n\t        nextPoint = points[i + 1];\n\t      }\n\t    }\n\t\n\t    v2Sub(v, nextPoint, prevPoint); // use degree to scale the handle length\n\t\n\t    v2Scale(v, v, smooth);\n\t    var d0 = v2Distance(point, prevPoint);\n\t    var d1 = v2Distance(point, nextPoint);\n\t    var sum = d0 + d1;\n\t\n\t    if (sum !== 0) {\n\t      d0 /= sum;\n\t      d1 /= sum;\n\t    }\n\t\n\t    v2Scale(v1, v, -d0);\n\t    v2Scale(v2, v, d1);\n\t    var cp0 = v2Add([], point, v1);\n\t    var cp1 = v2Add([], point, v2);\n\t\n\t    if (constraint) {\n\t      v2Max(cp0, cp0, min);\n\t      v2Min(cp0, cp0, max);\n\t      v2Max(cp1, cp1, min);\n\t      v2Min(cp1, cp1, max);\n\t    }\n\t\n\t    cps.push(cp0);\n\t    cps.push(cp1);\n\t  }\n\t\n\t  if (isLoop) {\n\t    cps.push(cps.shift());\n\t  }\n\t\n\t  return cps;\n\t}\n\t\n\tmodule.exports = _default;\n\n/***/ },\n/* 59 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar _vector = __webpack_require__(3);\n\t\n\tvar v2Distance = _vector.distance;\n\t\n\t/**\n\t * Catmull-Rom spline 插值折线\n\t * @module zrender/shape/util/smoothSpline\n\t * @author pissang (https://www.github.com/pissang)\n\t *         Kener (@Kener-林峰, kener.linfeng@gmail.com)\n\t *         errorrik (errorrik@gmail.com)\n\t */\n\t\n\t/**\n\t * @inner\n\t */\n\tfunction interpolate(p0, p1, p2, p3, t, t2, t3) {\n\t  var v0 = (p2 - p0) * 0.5;\n\t  var v1 = (p3 - p1) * 0.5;\n\t  return (2 * (p1 - p2) + v0 + v1) * t3 + (-3 * (p1 - p2) - 2 * v0 - v1) * t2 + v0 * t + p1;\n\t}\n\t/**\n\t * @alias module:zrender/shape/util/smoothSpline\n\t * @param {Array} points 线段顶点数组\n\t * @param {boolean} isLoop\n\t * @return {Array}\n\t */\n\t\n\t\n\tfunction _default(points, isLoop) {\n\t  var len = points.length;\n\t  var ret = [];\n\t  var distance = 0;\n\t\n\t  for (var i = 1; i < len; i++) {\n\t    distance += v2Distance(points[i - 1], points[i]);\n\t  }\n\t\n\t  var segs = distance / 2;\n\t  segs = segs < len ? len : segs;\n\t\n\t  for (var i = 0; i < segs; i++) {\n\t    var pos = i / (segs - 1) * (isLoop ? len : len - 1);\n\t    var idx = Math.floor(pos);\n\t    var w = pos - idx;\n\t    var p0;\n\t    var p1 = points[idx % len];\n\t    var p2;\n\t    var p3;\n\t\n\t    if (!isLoop) {\n\t      p0 = points[idx === 0 ? idx : idx - 1];\n\t      p2 = points[idx > len - 2 ? len - 1 : idx + 1];\n\t      p3 = points[idx > len - 3 ? len - 1 : idx + 2];\n\t    } else {\n\t      p0 = points[(idx - 1 + len) % len];\n\t      p2 = points[(idx + 1) % len];\n\t      p3 = points[(idx + 2) % len];\n\t    }\n\t\n\t    var w2 = w * w;\n\t    var w3 = w * w2;\n\t    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\t  }\n\t\n\t  return ret;\n\t}\n\t\n\tmodule.exports = _default;\n\n/***/ },\n/* 60 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar textHelper = __webpack_require__(24);\n\t\n\tvar BoundingRect = __webpack_require__(4);\n\t\n\t/**\n\t * Mixin for drawing text in a element bounding rect\n\t * @module zrender/mixin/RectText\n\t */\n\tvar tmpRect = new BoundingRect();\n\t\n\tvar RectText = function () {};\n\t\n\tRectText.prototype = {\n\t  constructor: RectText,\n\t\n\t  /**\n\t   * Draw text in a rect with specified position.\n\t   * @param  {CanvasRenderingContext2D} ctx\n\t   * @param  {Object} rect Displayable rect\n\t   */\n\t  drawRectText: function (ctx, rect) {\n\t    var style = this.style;\n\t    rect = style.textRect || rect; // Optimize, avoid normalize every time.\n\t\n\t    this.__dirty && textHelper.normalizeTextStyle(style, true);\n\t    var text = style.text; // Convert to string\n\t\n\t    text != null && (text += '');\n\t\n\t    if (!textHelper.needDrawText(text, style)) {\n\t      return;\n\t    } // FIXME\n\t\n\t\n\t    ctx.save(); // Transform rect to view space\n\t\n\t    var transform = this.transform;\n\t\n\t    if (!style.transformText) {\n\t      if (transform) {\n\t        tmpRect.copy(rect);\n\t        tmpRect.applyTransform(transform);\n\t        rect = tmpRect;\n\t      }\n\t    } else {\n\t      this.setTransform(ctx);\n\t    } // transformText and textRotation can not be used at the same time.\n\t\n\t\n\t    textHelper.renderText(this, ctx, text, style, rect);\n\t    ctx.restore();\n\t  }\n\t};\n\tvar _default = RectText;\n\tmodule.exports = _default;\n\n/***/ },\n/* 61 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar Path = __webpack_require__(2);\n\t\n\t/**\n\t * 圆弧\n\t * @module zrender/graphic/shape/Arc\n\t */\n\tvar _default = Path.extend({\n\t  type: 'arc',\n\t  shape: {\n\t    cx: 0,\n\t    cy: 0,\n\t    r: 0,\n\t    startAngle: 0,\n\t    endAngle: Math.PI * 2,\n\t    clockwise: true\n\t  },\n\t  style: {\n\t    stroke: '#000',\n\t    fill: null\n\t  },\n\t  buildPath: function (ctx, shape) {\n\t    var x = shape.cx;\n\t    var y = shape.cy;\n\t    var r = Math.max(shape.r, 0);\n\t    var startAngle = shape.startAngle;\n\t    var endAngle = shape.endAngle;\n\t    var clockwise = shape.clockwise;\n\t    var unitX = Math.cos(startAngle);\n\t    var unitY = Math.sin(startAngle);\n\t    ctx.moveTo(unitX * r + x, unitY * r + y);\n\t    ctx.arc(x, y, r, startAngle, endAngle, !clockwise);\n\t  }\n\t});\n\t\n\tmodule.exports = _default;\n\n/***/ },\n/* 62 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar Path = __webpack_require__(2);\n\t\n\tvar vec2 = __webpack_require__(3);\n\t\n\tvar _curve = __webpack_require__(5);\n\t\n\tvar quadraticSubdivide = _curve.quadraticSubdivide;\n\tvar cubicSubdivide = _curve.cubicSubdivide;\n\tvar quadraticAt = _curve.quadraticAt;\n\tvar cubicAt = _curve.cubicAt;\n\tvar quadraticDerivativeAt = _curve.quadraticDerivativeAt;\n\tvar cubicDerivativeAt = _curve.cubicDerivativeAt;\n\t\n\t/**\n\t * 贝塞尔曲线\n\t * @module zrender/shape/BezierCurve\n\t */\n\tvar out = [];\n\t\n\tfunction someVectorAt(shape, t, isTangent) {\n\t  var cpx2 = shape.cpx2;\n\t  var cpy2 = shape.cpy2;\n\t\n\t  if (cpx2 === null || cpy2 === null) {\n\t    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\t  } else {\n\t    return [(isTangent ? quadraticDerivativeAt : quadraticAt)(shape.x1, shape.cpx1, shape.x2, t), (isTangent ? quadraticDerivativeAt : quadraticAt)(shape.y1, shape.cpy1, shape.y2, t)];\n\t  }\n\t}\n\t\n\tvar _default = Path.extend({\n\t  type: 'bezier-curve',\n\t  shape: {\n\t    x1: 0,\n\t    y1: 0,\n\t    x2: 0,\n\t    y2: 0,\n\t    cpx1: 0,\n\t    cpy1: 0,\n\t    // cpx2: 0,\n\t    // cpy2: 0\n\t    // Curve show percent, for animating\n\t    percent: 1\n\t  },\n\t  style: {\n\t    stroke: '#000',\n\t    fill: null\n\t  },\n\t  buildPath: function (ctx, shape) {\n\t    var x1 = shape.x1;\n\t    var y1 = shape.y1;\n\t    var x2 = shape.x2;\n\t    var y2 = shape.y2;\n\t    var cpx1 = shape.cpx1;\n\t    var cpy1 = shape.cpy1;\n\t    var cpx2 = shape.cpx2;\n\t    var cpy2 = shape.cpy2;\n\t    var percent = shape.percent;\n\t\n\t    if (percent === 0) {\n\t      return;\n\t    }\n\t\n\t    ctx.moveTo(x1, y1);\n\t\n\t    if (cpx2 == null || cpy2 == null) {\n\t      if (percent < 1) {\n\t        quadraticSubdivide(x1, cpx1, x2, percent, out);\n\t        cpx1 = out[1];\n\t        x2 = out[2];\n\t        quadraticSubdivide(y1, cpy1, y2, percent, out);\n\t        cpy1 = out[1];\n\t        y2 = out[2];\n\t      }\n\t\n\t      ctx.quadraticCurveTo(cpx1, cpy1, x2, y2);\n\t    } else {\n\t      if (percent < 1) {\n\t        cubicSubdivide(x1, cpx1, cpx2, x2, percent, out);\n\t        cpx1 = out[1];\n\t        cpx2 = out[2];\n\t        x2 = out[3];\n\t        cubicSubdivide(y1, cpy1, cpy2, y2, percent, out);\n\t        cpy1 = out[1];\n\t        cpy2 = out[2];\n\t        y2 = out[3];\n\t      }\n\t\n\t      ctx.bezierCurveTo(cpx1, cpy1, cpx2, cpy2, x2, y2);\n\t    }\n\t  },\n\t\n\t  /**\n\t   * Get point at percent\n\t   * @param  {number} t\n\t   * @return {Array.<number>}\n\t   */\n\t  pointAt: function (t) {\n\t    return someVectorAt(this.shape, t, false);\n\t  },\n\t\n\t  /**\n\t   * Get tangent at percent\n\t   * @param  {number} t\n\t   * @return {Array.<number>}\n\t   */\n\t  tangentAt: function (t) {\n\t    var p = someVectorAt(this.shape, t, true);\n\t    return vec2.normalize(p, p);\n\t  }\n\t});\n\t\n\tmodule.exports = _default;\n\n/***/ },\n/* 63 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar Path = __webpack_require__(2);\n\t\n\t/**\n\t * 圆形\n\t * @module zrender/shape/Circle\n\t */\n\tvar _default = Path.extend({\n\t  type: 'circle',\n\t  shape: {\n\t    cx: 0,\n\t    cy: 0,\n\t    r: 0\n\t  },\n\t  buildPath: function (ctx, shape, inBundle) {\n\t    // Better stroking in ShapeBundle\n\t    // Always do it may have performence issue ( fill may be 2x more cost)\n\t    if (inBundle) {\n\t      ctx.moveTo(shape.cx + shape.r, shape.cy);\n\t    } // else {\n\t    //     if (ctx.allocate && !ctx.data.length) {\n\t    //         ctx.allocate(ctx.CMD_MEM_SIZE.A);\n\t    //     }\n\t    // }\n\t    // Better stroking in ShapeBundle\n\t    // ctx.moveTo(shape.cx + shape.r, shape.cy);\n\t\n\t\n\t    ctx.arc(shape.cx, shape.cy, shape.r, 0, Math.PI * 2, true);\n\t  }\n\t});\n\t\n\tmodule.exports = _default;\n\n/***/ },\n/* 64 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar Path = __webpack_require__(2);\n\t\n\t/**\n\t * 直线\n\t * @module zrender/graphic/shape/Line\n\t */\n\tvar _default = Path.extend({\n\t  type: 'line',\n\t  shape: {\n\t    // Start point\n\t    x1: 0,\n\t    y1: 0,\n\t    // End point\n\t    x2: 0,\n\t    y2: 0,\n\t    percent: 1\n\t  },\n\t  style: {\n\t    stroke: '#000',\n\t    fill: null\n\t  },\n\t  buildPath: function (ctx, shape) {\n\t    var x1 = shape.x1;\n\t    var y1 = shape.y1;\n\t    var x2 = shape.x2;\n\t    var y2 = shape.y2;\n\t    var percent = shape.percent;\n\t\n\t    if (percent === 0) {\n\t      return;\n\t    }\n\t\n\t    ctx.moveTo(x1, y1);\n\t\n\t    if (percent < 1) {\n\t      x2 = x1 * (1 - percent) + x2 * percent;\n\t      y2 = y1 * (1 - percent) + y2 * percent;\n\t    }\n\t\n\t    ctx.lineTo(x2, y2);\n\t  },\n\t\n\t  /**\n\t   * Get point at percent\n\t   * @param  {number} percent\n\t   * @return {Array.<number>}\n\t   */\n\t  pointAt: function (p) {\n\t    var shape = this.shape;\n\t    return [shape.x1 * (1 - p) + shape.x2 * p, shape.y1 * (1 - p) + shape.y2 * p];\n\t  }\n\t});\n\t\n\tmodule.exports = _default;\n\n/***/ },\n/* 65 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar Path = __webpack_require__(2);\n\t\n\tvar polyHelper = __webpack_require__(22);\n\t\n\t/**\n\t * 多边形\n\t * @module zrender/shape/Polygon\n\t */\n\tvar _default = Path.extend({\n\t  type: 'polygon',\n\t  shape: {\n\t    points: null,\n\t    smooth: false,\n\t    smoothConstraint: null\n\t  },\n\t  buildPath: function (ctx, shape) {\n\t    polyHelper.buildPath(ctx, shape, true);\n\t  }\n\t});\n\t\n\tmodule.exports = _default;\n\n/***/ },\n/* 66 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar Path = __webpack_require__(2);\n\t\n\tvar polyHelper = __webpack_require__(22);\n\t\n\t/**\n\t * @module zrender/graphic/shape/Polyline\n\t */\n\tvar _default = Path.extend({\n\t  type: 'polyline',\n\t  shape: {\n\t    points: null,\n\t    smooth: false,\n\t    smoothConstraint: null\n\t  },\n\t  style: {\n\t    stroke: '#000',\n\t    fill: null\n\t  },\n\t  buildPath: function (ctx, shape) {\n\t    polyHelper.buildPath(ctx, shape, false);\n\t  }\n\t});\n\t\n\tmodule.exports = _default;\n\n/***/ },\n/* 67 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar Path = __webpack_require__(2);\n\t\n\tvar roundRectHelper = __webpack_require__(23);\n\t\n\t/**\n\t * 矩形\n\t * @module zrender/graphic/shape/Rect\n\t */\n\tvar _default = Path.extend({\n\t  type: 'rect',\n\t  shape: {\n\t    // 左上、右上、右下、左下角的半径依次为r1、r2、r3、r4\n\t    // r缩写为1         相当于 [1, 1, 1, 1]\n\t    // r缩写为[1]       相当于 [1, 1, 1, 1]\n\t    // r缩写为[1, 2]    相当于 [1, 2, 1, 2]\n\t    // r缩写为[1, 2, 3] 相当于 [1, 2, 3, 2]\n\t    r: 0,\n\t    x: 0,\n\t    y: 0,\n\t    width: 0,\n\t    height: 0\n\t  },\n\t  buildPath: function (ctx, shape) {\n\t    var x = shape.x;\n\t    var y = shape.y;\n\t    var width = shape.width;\n\t    var height = shape.height;\n\t\n\t    if (!shape.r) {\n\t      ctx.rect(x, y, width, height);\n\t    } else {\n\t      roundRectHelper.buildPath(ctx, shape);\n\t    }\n\t\n\t    ctx.closePath();\n\t    return;\n\t  }\n\t});\n\t\n\tmodule.exports = _default;\n\n/***/ },\n/* 68 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar Path = __webpack_require__(2);\n\t\n\t/**\n\t * 圆环\n\t * @module zrender/graphic/shape/Ring\n\t */\n\tvar _default = Path.extend({\n\t  type: 'ring',\n\t  shape: {\n\t    cx: 0,\n\t    cy: 0,\n\t    r: 0,\n\t    r0: 0\n\t  },\n\t  buildPath: function (ctx, shape) {\n\t    var x = shape.cx;\n\t    var y = shape.cy;\n\t    var PI2 = Math.PI * 2;\n\t    ctx.moveTo(x + shape.r, y);\n\t    ctx.arc(x, y, shape.r, 0, PI2, false);\n\t    ctx.moveTo(x + shape.r0, y);\n\t    ctx.arc(x, y, shape.r0, 0, PI2, true);\n\t  }\n\t});\n\t\n\tmodule.exports = _default;\n\n/***/ },\n/* 69 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar Path = __webpack_require__(2);\n\t\n\tvar fixClipWithShadow = __webpack_require__(57);\n\t\n\t/**\n\t * 扇形\n\t * @module zrender/graphic/shape/Sector\n\t */\n\tvar _default = Path.extend({\n\t  type: 'sector',\n\t  shape: {\n\t    cx: 0,\n\t    cy: 0,\n\t    r0: 0,\n\t    r: 0,\n\t    startAngle: 0,\n\t    endAngle: Math.PI * 2,\n\t    clockwise: true\n\t  },\n\t  brush: fixClipWithShadow(Path.prototype.brush),\n\t  buildPath: function (ctx, shape) {\n\t    var x = shape.cx;\n\t    var y = shape.cy;\n\t    var r0 = Math.max(shape.r0 || 0, 0);\n\t    var r = Math.max(shape.r, 0);\n\t    var startAngle = shape.startAngle;\n\t    var endAngle = shape.endAngle;\n\t    var clockwise = shape.clockwise;\n\t    var unitX = Math.cos(startAngle);\n\t    var unitY = Math.sin(startAngle);\n\t    ctx.moveTo(unitX * r0 + x, unitY * r0 + y);\n\t    ctx.lineTo(unitX * r + x, unitY * r + y);\n\t    ctx.arc(x, y, r, startAngle, endAngle, !clockwise);\n\t    ctx.lineTo(Math.cos(endAngle) * r0 + x, Math.sin(endAngle) * r0 + y);\n\t\n\t    if (r0 !== 0) {\n\t      ctx.arc(x, y, r0, endAngle, startAngle, clockwise);\n\t    }\n\t\n\t    ctx.closePath();\n\t  }\n\t});\n\t\n\tmodule.exports = _default;\n\n/***/ },\n/* 70 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar Animator = __webpack_require__(35);\n\t\n\tvar log = __webpack_require__(48);\n\t\n\tvar _util = __webpack_require__(1);\n\t\n\tvar isString = _util.isString;\n\tvar isFunction = _util.isFunction;\n\tvar isObject = _util.isObject;\n\tvar isArrayLike = _util.isArrayLike;\n\tvar indexOf = _util.indexOf;\n\t\n\t/**\n\t * @alias modue:zrender/mixin/Animatable\n\t * @constructor\n\t */\n\tvar Animatable = function () {\n\t  /**\n\t   * @type {Array.<module:zrender/animation/Animator>}\n\t   * @readOnly\n\t   */\n\t  this.animators = [];\n\t};\n\t\n\tAnimatable.prototype = {\n\t  constructor: Animatable,\n\t\n\t  /**\n\t   * 动画\n\t   *\n\t   * @param {string} path The path to fetch value from object, like 'a.b.c'.\n\t   * @param {boolean} [loop] Whether to loop animation.\n\t   * @return {module:zrender/animation/Animator}\n\t   * @example:\n\t   *     el.animate('style', false)\n\t   *         .when(1000, {x: 10} )\n\t   *         .done(function(){ // Animation done })\n\t   *         .start()\n\t   */\n\t  animate: function (path, loop) {\n\t    var target;\n\t    var animatingShape = false;\n\t    var el = this;\n\t    var zr = this.__zr;\n\t\n\t    if (path) {\n\t      var pathSplitted = path.split('.');\n\t      var prop = el; // If animating shape\n\t\n\t      animatingShape = pathSplitted[0] === 'shape';\n\t\n\t      for (var i = 0, l = pathSplitted.length; i < l; i++) {\n\t        if (!prop) {\n\t          continue;\n\t        }\n\t\n\t        prop = prop[pathSplitted[i]];\n\t      }\n\t\n\t      if (prop) {\n\t        target = prop;\n\t      }\n\t    } else {\n\t      target = el;\n\t    }\n\t\n\t    if (!target) {\n\t      log('Property \"' + path + '\" is not existed in element ' + el.id);\n\t      return;\n\t    }\n\t\n\t    var animators = el.animators;\n\t    var animator = new Animator(target, loop);\n\t    animator.during(function (target) {\n\t      el.dirty(animatingShape);\n\t    }).done(function () {\n\t      // FIXME Animator will not be removed if use `Animator#stop` to stop animation\n\t      animators.splice(indexOf(animators, animator), 1);\n\t    });\n\t    animators.push(animator); // If animate after added to the zrender\n\t\n\t    if (zr) {\n\t      zr.animation.addAnimator(animator);\n\t    }\n\t\n\t    return animator;\n\t  },\n\t\n\t  /**\n\t   * 停止动画\n\t   * @param {boolean} forwardToLast If move to last frame before stop\n\t   */\n\t  stopAnimation: function (forwardToLast) {\n\t    var animators = this.animators;\n\t    var len = animators.length;\n\t\n\t    for (var i = 0; i < len; i++) {\n\t      animators[i].stop(forwardToLast);\n\t    }\n\t\n\t    animators.length = 0;\n\t    return this;\n\t  },\n\t\n\t  /**\n\t   * Caution: this method will stop previous animation.\n\t   * So do not use this method to one element twice before\n\t   * animation starts, unless you know what you are doing.\n\t   * @param {Object} target\n\t   * @param {number} [time=500] Time in ms\n\t   * @param {string} [easing='linear']\n\t   * @param {number} [delay=0]\n\t   * @param {Function} [callback]\n\t   * @param {Function} [forceAnimate] Prevent stop animation and callback\n\t   *        immediently when target values are the same as current values.\n\t   *\n\t   * @example\n\t   *  // Animate position\n\t   *  el.animateTo({\n\t   *      position: [10, 10]\n\t   *  }, function () { // done })\n\t   *\n\t   *  // Animate shape, style and position in 100ms, delayed 100ms, with cubicOut easing\n\t   *  el.animateTo({\n\t   *      shape: {\n\t   *          width: 500\n\t   *      },\n\t   *      style: {\n\t   *          fill: 'red'\n\t   *      }\n\t   *      position: [10, 10]\n\t   *  }, 100, 100, 'cubicOut', function () { // done })\n\t   */\n\t  // TODO Return animation key\n\t  animateTo: function (target, time, delay, easing, callback, forceAnimate) {\n\t    // animateTo(target, time, easing, callback);\n\t    if (isString(delay)) {\n\t      callback = easing;\n\t      easing = delay;\n\t      delay = 0;\n\t    } // animateTo(target, time, delay, callback);\n\t    else if (isFunction(easing)) {\n\t        callback = easing;\n\t        easing = 'linear';\n\t        delay = 0;\n\t      } // animateTo(target, time, callback);\n\t      else if (isFunction(delay)) {\n\t          callback = delay;\n\t          delay = 0;\n\t        } // animateTo(target, callback)\n\t        else if (isFunction(time)) {\n\t            callback = time;\n\t            time = 500;\n\t          } // animateTo(target)\n\t          else if (!time) {\n\t              time = 500;\n\t            } // Stop all previous animations\n\t\n\t\n\t    this.stopAnimation();\n\t\n\t    this._animateToShallow('', this, target, time, delay); // Animators may be removed immediately after start\n\t    // if there is nothing to animate\n\t\n\t\n\t    var animators = this.animators.slice();\n\t    var count = animators.length;\n\t\n\t    function done() {\n\t      count--;\n\t\n\t      if (!count) {\n\t        callback && callback();\n\t      }\n\t    } // No animators. This should be checked before animators[i].start(),\n\t    // because 'done' may be executed immediately if no need to animate.\n\t\n\t\n\t    if (!count) {\n\t      callback && callback();\n\t    } // Start after all animators created\n\t    // Incase any animator is done immediately when all animation properties are not changed\n\t\n\t\n\t    for (var i = 0; i < animators.length; i++) {\n\t      animators[i].done(done).start(easing, forceAnimate);\n\t    }\n\t  },\n\t\n\t  /**\n\t   * @private\n\t   * @param {string} path=''\n\t   * @param {Object} source=this\n\t   * @param {Object} target\n\t   * @param {number} [time=500]\n\t   * @param {number} [delay=0]\n\t   *\n\t   * @example\n\t   *  // Animate position\n\t   *  el._animateToShallow({\n\t   *      position: [10, 10]\n\t   *  })\n\t   *\n\t   *  // Animate shape, style and position in 100ms, delayed 100ms\n\t   *  el._animateToShallow({\n\t   *      shape: {\n\t   *          width: 500\n\t   *      },\n\t   *      style: {\n\t   *          fill: 'red'\n\t   *      }\n\t   *      position: [10, 10]\n\t   *  }, 100, 100)\n\t   */\n\t  _animateToShallow: function (path, source, target, time, delay) {\n\t    var objShallow = {};\n\t    var propertyCount = 0;\n\t\n\t    for (var name in target) {\n\t      if (!target.hasOwnProperty(name)) {\n\t        continue;\n\t      }\n\t\n\t      if (source[name] != null) {\n\t        if (isObject(target[name]) && !isArrayLike(target[name])) {\n\t          this._animateToShallow(path ? path + '.' + name : name, source[name], target[name], time, delay);\n\t        } else {\n\t          objShallow[name] = target[name];\n\t          propertyCount++;\n\t        }\n\t      } else if (target[name] != null) {\n\t        // Attr directly if not has property\n\t        // FIXME, if some property not needed for element ?\n\t        if (!path) {\n\t          this.attr(name, target[name]);\n\t        } else {\n\t          // Shape or style\n\t          var props = {};\n\t          props[path] = {};\n\t          props[path][name] = target[name];\n\t          this.attr(props);\n\t        }\n\t      }\n\t    }\n\t\n\t    if (propertyCount > 0) {\n\t      this.animate(path, false).when(time == null ? 500 : time, objShallow).delay(delay || 0);\n\t    }\n\t\n\t    return this;\n\t  }\n\t};\n\tvar _default = Animatable;\n\tmodule.exports = _default;\n\n/***/ },\n/* 71 */\n/***/ function(module, exports) {\n\n\t/**\n\t * 事件扩展\n\t * @module zrender/mixin/Eventful\n\t * @author Kener (@Kener-林峰, kener.linfeng@gmail.com)\n\t *         pissang (https://www.github.com/pissang)\n\t */\n\tvar arrySlice = Array.prototype.slice;\n\t/**\n\t * 事件分发器\n\t * @alias module:zrender/mixin/Eventful\n\t * @constructor\n\t */\n\t\n\tvar Eventful = function () {\n\t  this._$handlers = {};\n\t};\n\t\n\tEventful.prototype = {\n\t  constructor: Eventful,\n\t\n\t  /**\n\t   * 单次触发绑定，trigger后销毁\n\t   *\n\t   * @param {string} event 事件名\n\t   * @param {Function} handler 响应函数\n\t   * @param {Object} context\n\t   */\n\t  one: function (event, handler, context) {\n\t    var _h = this._$handlers;\n\t\n\t    if (!handler || !event) {\n\t      return this;\n\t    }\n\t\n\t    if (!_h[event]) {\n\t      _h[event] = [];\n\t    }\n\t\n\t    for (var i = 0; i < _h[event].length; i++) {\n\t      if (_h[event][i].h === handler) {\n\t        return this;\n\t      }\n\t    }\n\t\n\t    _h[event].push({\n\t      h: handler,\n\t      one: true,\n\t      ctx: context || this\n\t    });\n\t\n\t    return this;\n\t  },\n\t\n\t  /**\n\t   * 绑定事件\n\t   * @param {string} event 事件名\n\t   * @param {Function} handler 事件处理函数\n\t   * @param {Object} [context]\n\t   */\n\t  on: function (event, handler, context) {\n\t    var _h = this._$handlers;\n\t\n\t    if (!handler || !event) {\n\t      return this;\n\t    }\n\t\n\t    if (!_h[event]) {\n\t      _h[event] = [];\n\t    }\n\t\n\t    for (var i = 0; i < _h[event].length; i++) {\n\t      if (_h[event][i].h === handler) {\n\t        return this;\n\t      }\n\t    }\n\t\n\t    _h[event].push({\n\t      h: handler,\n\t      one: false,\n\t      ctx: context || this\n\t    });\n\t\n\t    return this;\n\t  },\n\t\n\t  /**\n\t   * 是否绑定了事件\n\t   * @param  {string}  event\n\t   * @return {boolean}\n\t   */\n\t  isSilent: function (event) {\n\t    var _h = this._$handlers;\n\t    return _h[event] && _h[event].length;\n\t  },\n\t\n\t  /**\n\t   * 解绑事件\n\t   * @param {string} event 事件名\n\t   * @param {Function} [handler] 事件处理函数\n\t   */\n\t  off: function (event, handler) {\n\t    var _h = this._$handlers;\n\t\n\t    if (!event) {\n\t      this._$handlers = {};\n\t      return this;\n\t    }\n\t\n\t    if (handler) {\n\t      if (_h[event]) {\n\t        var newList = [];\n\t\n\t        for (var i = 0, l = _h[event].length; i < l; i++) {\n\t          if (_h[event][i]['h'] != handler) {\n\t            newList.push(_h[event][i]);\n\t          }\n\t        }\n\t\n\t        _h[event] = newList;\n\t      }\n\t\n\t      if (_h[event] && _h[event].length === 0) {\n\t        delete _h[event];\n\t      }\n\t    } else {\n\t      delete _h[event];\n\t    }\n\t\n\t    return this;\n\t  },\n\t\n\t  /**\n\t   * 事件分发\n\t   *\n\t   * @param {string} type 事件类型\n\t   */\n\t  trigger: function (type) {\n\t    if (this._$handlers[type]) {\n\t      var args = arguments;\n\t      var argLen = args.length;\n\t\n\t      if (argLen > 3) {\n\t        args = arrySlice.call(args, 1);\n\t      }\n\t\n\t      var _h = this._$handlers[type];\n\t      var len = _h.length;\n\t\n\t      for (var i = 0; i < len;) {\n\t        // Optimize advise from backbone\n\t        switch (argLen) {\n\t          case 1:\n\t            _h[i]['h'].call(_h[i]['ctx']);\n\t\n\t            break;\n\t\n\t          case 2:\n\t            _h[i]['h'].call(_h[i]['ctx'], args[1]);\n\t\n\t            break;\n\t\n\t          case 3:\n\t            _h[i]['h'].call(_h[i]['ctx'], args[1], args[2]);\n\t\n\t            break;\n\t\n\t          default:\n\t            // have more than 2 given arguments\n\t            _h[i]['h'].apply(_h[i]['ctx'], args);\n\t\n\t            break;\n\t        }\n\t\n\t        if (_h[i]['one']) {\n\t          _h.splice(i, 1);\n\t\n\t          len--;\n\t        } else {\n\t          i++;\n\t        }\n\t      }\n\t    }\n\t\n\t    return this;\n\t  },\n\t\n\t  /**\n\t   * 带有context的事件分发, 最后一个参数是事件回调的context\n\t   * @param {string} type 事件类型\n\t   */\n\t  triggerWithContext: function (type) {\n\t    if (this._$handlers[type]) {\n\t      var args = arguments;\n\t      var argLen = args.length;\n\t\n\t      if (argLen > 4) {\n\t        args = arrySlice.call(args, 1, args.length - 1);\n\t      }\n\t\n\t      var ctx = args[args.length - 1];\n\t      var _h = this._$handlers[type];\n\t      var len = _h.length;\n\t\n\t      for (var i = 0; i < len;) {\n\t        // Optimize advise from backbone\n\t        switch (argLen) {\n\t          case 1:\n\t            _h[i]['h'].call(ctx);\n\t\n\t            break;\n\t\n\t          case 2:\n\t            _h[i]['h'].call(ctx, args[1]);\n\t\n\t            break;\n\t\n\t          case 3:\n\t            _h[i]['h'].call(ctx, args[1], args[2]);\n\t\n\t            break;\n\t\n\t          default:\n\t            // have more than 2 given arguments\n\t            _h[i]['h'].apply(ctx, args);\n\t\n\t            break;\n\t        }\n\t\n\t        if (_h[i]['one']) {\n\t          _h.splice(i, 1);\n\t\n\t          len--;\n\t        } else {\n\t          i++;\n\t        }\n\t      }\n\t    }\n\t\n\t    return this;\n\t  }\n\t}; // 对象可以通过 onxxxx 绑定事件\n\t\n\t/**\n\t * @event module:zrender/mixin/Eventful#onclick\n\t * @type {Function}\n\t * @default null\n\t */\n\t\n\t/**\n\t * @event module:zrender/mixin/Eventful#onmouseover\n\t * @type {Function}\n\t * @default null\n\t */\n\t\n\t/**\n\t * @event module:zrender/mixin/Eventful#onmouseout\n\t * @type {Function}\n\t * @default null\n\t */\n\t\n\t/**\n\t * @event module:zrender/mixin/Eventful#onmousemove\n\t * @type {Function}\n\t * @default null\n\t */\n\t\n\t/**\n\t * @event module:zrender/mixin/Eventful#onmousewheel\n\t * @type {Function}\n\t * @default null\n\t */\n\t\n\t/**\n\t * @event module:zrender/mixin/Eventful#onmousedown\n\t * @type {Function}\n\t * @default null\n\t */\n\t\n\t/**\n\t * @event module:zrender/mixin/Eventful#onmouseup\n\t * @type {Function}\n\t * @default null\n\t */\n\t\n\t/**\n\t * @event module:zrender/mixin/Eventful#ondrag\n\t * @type {Function}\n\t * @default null\n\t */\n\t\n\t/**\n\t * @event module:zrender/mixin/Eventful#ondragstart\n\t * @type {Function}\n\t * @default null\n\t */\n\t\n\t/**\n\t * @event module:zrender/mixin/Eventful#ondragend\n\t * @type {Function}\n\t * @default null\n\t */\n\t\n\t/**\n\t * @event module:zrender/mixin/Eventful#ondragenter\n\t * @type {Function}\n\t * @default null\n\t */\n\t\n\t/**\n\t * @event module:zrender/mixin/Eventful#ondragleave\n\t * @type {Function}\n\t * @default null\n\t */\n\t\n\t/**\n\t * @event module:zrender/mixin/Eventful#ondragover\n\t * @type {Function}\n\t * @default null\n\t */\n\t\n\t/**\n\t * @event module:zrender/mixin/Eventful#ondrop\n\t * @type {Function}\n\t * @default null\n\t */\n\t\n\tvar _default = Eventful;\n\tmodule.exports = _default;\n\n/***/ },\n/* 72 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar Path = __webpack_require__(2);\n\t\n\tvar PathProxy = __webpack_require__(7);\n\t\n\tvar transformPath = __webpack_require__(73);\n\t\n\t// command chars\n\tvar cc = ['m', 'M', 'l', 'L', 'v', 'V', 'h', 'H', 'z', 'Z', 'c', 'C', 'q', 'Q', 't', 'T', 's', 'S', 'a', 'A'];\n\tvar mathSqrt = Math.sqrt;\n\tvar mathSin = Math.sin;\n\tvar mathCos = Math.cos;\n\tvar PI = Math.PI;\n\t\n\tvar vMag = function (v) {\n\t  return Math.sqrt(v[0] * v[0] + v[1] * v[1]);\n\t};\n\t\n\tvar vRatio = function (u, v) {\n\t  return (u[0] * v[0] + u[1] * v[1]) / (vMag(u) * vMag(v));\n\t};\n\t\n\tvar vAngle = function (u, v) {\n\t  return (u[0] * v[1] < u[1] * v[0] ? -1 : 1) * Math.acos(vRatio(u, v));\n\t};\n\t\n\tfunction processArc(x1, y1, x2, y2, fa, fs, rx, ry, psiDeg, cmd, path) {\n\t  var psi = psiDeg * (PI / 180.0);\n\t  var xp = mathCos(psi) * (x1 - x2) / 2.0 + mathSin(psi) * (y1 - y2) / 2.0;\n\t  var yp = -1 * mathSin(psi) * (x1 - x2) / 2.0 + mathCos(psi) * (y1 - y2) / 2.0;\n\t  var lambda = xp * xp / (rx * rx) + yp * yp / (ry * ry);\n\t\n\t  if (lambda > 1) {\n\t    rx *= mathSqrt(lambda);\n\t    ry *= mathSqrt(lambda);\n\t  }\n\t\n\t  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\t  var cxp = f * rx * yp / ry;\n\t  var cyp = f * -ry * xp / rx;\n\t  var cx = (x1 + x2) / 2.0 + mathCos(psi) * cxp - mathSin(psi) * cyp;\n\t  var cy = (y1 + y2) / 2.0 + mathSin(psi) * cxp + mathCos(psi) * cyp;\n\t  var theta = vAngle([1, 0], [(xp - cxp) / rx, (yp - cyp) / ry]);\n\t  var u = [(xp - cxp) / rx, (yp - cyp) / ry];\n\t  var v = [(-1 * xp - cxp) / rx, (-1 * yp - cyp) / ry];\n\t  var dTheta = vAngle(u, v);\n\t\n\t  if (vRatio(u, v) <= -1) {\n\t    dTheta = PI;\n\t  }\n\t\n\t  if (vRatio(u, v) >= 1) {\n\t    dTheta = 0;\n\t  }\n\t\n\t  if (fs === 0 && dTheta > 0) {\n\t    dTheta = dTheta - 2 * PI;\n\t  }\n\t\n\t  if (fs === 1 && dTheta < 0) {\n\t    dTheta = dTheta + 2 * PI;\n\t  }\n\t\n\t  path.addData(cmd, cx, cy, rx, ry, theta, dTheta, psi, fs);\n\t}\n\t\n\tfunction createPathProxyFromString(data) {\n\t  if (!data) {\n\t    return [];\n\t  } // command string\n\t\n\t\n\t  var cs = data.replace(/-/g, ' -').replace(/  /g, ' ').replace(/ /g, ',').replace(/,,/g, ',');\n\t  var n; // create pipes so that we can split the data\n\t\n\t  for (n = 0; n < cc.length; n++) {\n\t    cs = cs.replace(new RegExp(cc[n], 'g'), '|' + cc[n]);\n\t  } // create array\n\t\n\t\n\t  var arr = cs.split('|'); // init context point\n\t\n\t  var cpx = 0;\n\t  var cpy = 0;\n\t  var path = new PathProxy();\n\t  var CMD = PathProxy.CMD;\n\t  var prevCmd;\n\t\n\t  for (n = 1; n < arr.length; n++) {\n\t    var str = arr[n];\n\t    var c = str.charAt(0);\n\t    var off = 0;\n\t    var p = str.slice(1).replace(/e,-/g, 'e-').split(',');\n\t    var cmd;\n\t\n\t    if (p.length > 0 && p[0] === '') {\n\t      p.shift();\n\t    }\n\t\n\t    for (var i = 0; i < p.length; i++) {\n\t      p[i] = parseFloat(p[i]);\n\t    }\n\t\n\t    while (off < p.length && !isNaN(p[off])) {\n\t      if (isNaN(p[0])) {\n\t        break;\n\t      }\n\t\n\t      var ctlPtx;\n\t      var ctlPty;\n\t      var rx;\n\t      var ry;\n\t      var psi;\n\t      var fa;\n\t      var fs;\n\t      var x1 = cpx;\n\t      var y1 = cpy; // convert l, H, h, V, and v to L\n\t\n\t      switch (c) {\n\t        case 'l':\n\t          cpx += p[off++];\n\t          cpy += p[off++];\n\t          cmd = CMD.L;\n\t          path.addData(cmd, cpx, cpy);\n\t          break;\n\t\n\t        case 'L':\n\t          cpx = p[off++];\n\t          cpy = p[off++];\n\t          cmd = CMD.L;\n\t          path.addData(cmd, cpx, cpy);\n\t          break;\n\t\n\t        case 'm':\n\t          cpx += p[off++];\n\t          cpy += p[off++];\n\t          cmd = CMD.M;\n\t          path.addData(cmd, cpx, cpy);\n\t          c = 'l';\n\t          break;\n\t\n\t        case 'M':\n\t          cpx = p[off++];\n\t          cpy = p[off++];\n\t          cmd = CMD.M;\n\t          path.addData(cmd, cpx, cpy);\n\t          c = 'L';\n\t          break;\n\t\n\t        case 'h':\n\t          cpx += p[off++];\n\t          cmd = CMD.L;\n\t          path.addData(cmd, cpx, cpy);\n\t          break;\n\t\n\t        case 'H':\n\t          cpx = p[off++];\n\t          cmd = CMD.L;\n\t          path.addData(cmd, cpx, cpy);\n\t          break;\n\t\n\t        case 'v':\n\t          cpy += p[off++];\n\t          cmd = CMD.L;\n\t          path.addData(cmd, cpx, cpy);\n\t          break;\n\t\n\t        case 'V':\n\t          cpy = p[off++];\n\t          cmd = CMD.L;\n\t          path.addData(cmd, cpx, cpy);\n\t          break;\n\t\n\t        case 'C':\n\t          cmd = CMD.C;\n\t          path.addData(cmd, p[off++], p[off++], p[off++], p[off++], p[off++], p[off++]);\n\t          cpx = p[off - 2];\n\t          cpy = p[off - 1];\n\t          break;\n\t\n\t        case 'c':\n\t          cmd = CMD.C;\n\t          path.addData(cmd, p[off++] + cpx, p[off++] + cpy, p[off++] + cpx, p[off++] + cpy, p[off++] + cpx, p[off++] + cpy);\n\t          cpx += p[off - 2];\n\t          cpy += p[off - 1];\n\t          break;\n\t\n\t        case 'S':\n\t          ctlPtx = cpx;\n\t          ctlPty = cpy;\n\t          var len = path.len();\n\t          var pathData = path.data;\n\t\n\t          if (prevCmd === CMD.C) {\n\t            ctlPtx += cpx - pathData[len - 4];\n\t            ctlPty += cpy - pathData[len - 3];\n\t          }\n\t\n\t          cmd = CMD.C;\n\t          x1 = p[off++];\n\t          y1 = p[off++];\n\t          cpx = p[off++];\n\t          cpy = p[off++];\n\t          path.addData(cmd, ctlPtx, ctlPty, x1, y1, cpx, cpy);\n\t          break;\n\t\n\t        case 's':\n\t          ctlPtx = cpx;\n\t          ctlPty = cpy;\n\t          var len = path.len();\n\t          var pathData = path.data;\n\t\n\t          if (prevCmd === CMD.C) {\n\t            ctlPtx += cpx - pathData[len - 4];\n\t            ctlPty += cpy - pathData[len - 3];\n\t          }\n\t\n\t          cmd = CMD.C;\n\t          x1 = cpx + p[off++];\n\t          y1 = cpy + p[off++];\n\t          cpx += p[off++];\n\t          cpy += p[off++];\n\t          path.addData(cmd, ctlPtx, ctlPty, x1, y1, cpx, cpy);\n\t          break;\n\t\n\t        case 'Q':\n\t          x1 = p[off++];\n\t          y1 = p[off++];\n\t          cpx = p[off++];\n\t          cpy = p[off++];\n\t          cmd = CMD.Q;\n\t          path.addData(cmd, x1, y1, cpx, cpy);\n\t          break;\n\t\n\t        case 'q':\n\t          x1 = p[off++] + cpx;\n\t          y1 = p[off++] + cpy;\n\t          cpx += p[off++];\n\t          cpy += p[off++];\n\t          cmd = CMD.Q;\n\t          path.addData(cmd, x1, y1, cpx, cpy);\n\t          break;\n\t\n\t        case 'T':\n\t          ctlPtx = cpx;\n\t          ctlPty = cpy;\n\t          var len = path.len();\n\t          var pathData = path.data;\n\t\n\t          if (prevCmd === CMD.Q) {\n\t            ctlPtx += cpx - pathData[len - 4];\n\t            ctlPty += cpy - pathData[len - 3];\n\t          }\n\t\n\t          cpx = p[off++];\n\t          cpy = p[off++];\n\t          cmd = CMD.Q;\n\t          path.addData(cmd, ctlPtx, ctlPty, cpx, cpy);\n\t          break;\n\t\n\t        case 't':\n\t          ctlPtx = cpx;\n\t          ctlPty = cpy;\n\t          var len = path.len();\n\t          var pathData = path.data;\n\t\n\t          if (prevCmd === CMD.Q) {\n\t            ctlPtx += cpx - pathData[len - 4];\n\t            ctlPty += cpy - pathData[len - 3];\n\t          }\n\t\n\t          cpx += p[off++];\n\t          cpy += p[off++];\n\t          cmd = CMD.Q;\n\t          path.addData(cmd, ctlPtx, ctlPty, cpx, cpy);\n\t          break;\n\t\n\t        case 'A':\n\t          rx = p[off++];\n\t          ry = p[off++];\n\t          psi = p[off++];\n\t          fa = p[off++];\n\t          fs = p[off++];\n\t          x1 = cpx, y1 = cpy;\n\t          cpx = p[off++];\n\t          cpy = p[off++];\n\t          cmd = CMD.A;\n\t          processArc(x1, y1, cpx, cpy, fa, fs, rx, ry, psi, cmd, path);\n\t          break;\n\t\n\t        case 'a':\n\t          rx = p[off++];\n\t          ry = p[off++];\n\t          psi = p[off++];\n\t          fa = p[off++];\n\t          fs = p[off++];\n\t          x1 = cpx, y1 = cpy;\n\t          cpx += p[off++];\n\t          cpy += p[off++];\n\t          cmd = CMD.A;\n\t          processArc(x1, y1, cpx, cpy, fa, fs, rx, ry, psi, cmd, path);\n\t          break;\n\t      }\n\t    }\n\t\n\t    if (c === 'z' || c === 'Z') {\n\t      cmd = CMD.Z;\n\t      path.addData(cmd);\n\t    }\n\t\n\t    prevCmd = cmd;\n\t  }\n\t\n\t  path.toStatic();\n\t  return path;\n\t} // TODO Optimize double memory cost problem\n\t\n\t\n\tfunction createPathOptions(str, opts) {\n\t  var pathProxy = createPathProxyFromString(str);\n\t  opts = opts || {};\n\t\n\t  opts.buildPath = function (path) {\n\t    if (path.setData) {\n\t      path.setData(pathProxy.data); // Svg and vml renderer don't have context\n\t\n\t      var ctx = path.getContext();\n\t\n\t      if (ctx) {\n\t        path.rebuildPath(ctx);\n\t      }\n\t    } else {\n\t      var ctx = path;\n\t      pathProxy.rebuildPath(ctx);\n\t    }\n\t  };\n\t\n\t  opts.applyTransform = function (m) {\n\t    transformPath(pathProxy, m);\n\t    this.dirty(true);\n\t  };\n\t\n\t  return opts;\n\t}\n\t/**\n\t * Create a Path object from path string data\n\t * http://www.w3.org/TR/SVG/paths.html#PathData\n\t * @param  {Object} opts Other options\n\t */\n\t\n\t\n\tfunction createFromString(str, opts) {\n\t  return new Path(createPathOptions(str, opts));\n\t}\n\t/**\n\t * Create a Path class from path string data\n\t * @param  {string} str\n\t * @param  {Object} opts Other options\n\t */\n\t\n\t\n\tfunction extendFromString(str, opts) {\n\t  return Path.extend(createPathOptions(str, opts));\n\t}\n\t/**\n\t * Merge multiple paths\n\t */\n\t// TODO Apply transform\n\t// TODO stroke dash\n\t// TODO Optimize double memory cost problem\n\t\n\t\n\tfunction mergePath(pathEls, opts) {\n\t  var pathList = [];\n\t  var len = pathEls.length;\n\t\n\t  for (var i = 0; i < len; i++) {\n\t    var pathEl = pathEls[i];\n\t\n\t    if (!pathEl.path) {\n\t      pathEl.createPathProxy();\n\t    }\n\t\n\t    if (pathEl.__dirtyPath) {\n\t      pathEl.buildPath(pathEl.path, pathEl.shape, true);\n\t    }\n\t\n\t    pathList.push(pathEl.path);\n\t  }\n\t\n\t  var pathBundle = new Path(opts); // Need path proxy.\n\t\n\t  pathBundle.createPathProxy();\n\t\n\t  pathBundle.buildPath = function (path) {\n\t    path.appendPath(pathList); // Svg and vml renderer don't have context\n\t\n\t    var ctx = path.getContext();\n\t\n\t    if (ctx) {\n\t      path.rebuildPath(ctx);\n\t    }\n\t  };\n\t\n\t  return pathBundle;\n\t}\n\t\n\texports.createFromString = createFromString;\n\texports.extendFromString = extendFromString;\n\texports.mergePath = mergePath;\n\n/***/ },\n/* 73 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar PathProxy = __webpack_require__(7);\n\t\n\tvar _vector = __webpack_require__(3);\n\t\n\tvar v2ApplyTransform = _vector.applyTransform;\n\tvar CMD = PathProxy.CMD;\n\tvar points = [[], [], []];\n\tvar mathSqrt = Math.sqrt;\n\tvar mathAtan2 = Math.atan2;\n\t\n\tfunction _default(path, m) {\n\t  var data = path.data;\n\t  var cmd;\n\t  var nPoint;\n\t  var i;\n\t  var j;\n\t  var k;\n\t  var p;\n\t  var M = CMD.M;\n\t  var C = CMD.C;\n\t  var L = CMD.L;\n\t  var R = CMD.R;\n\t  var A = CMD.A;\n\t  var Q = CMD.Q;\n\t\n\t  for (i = 0, j = 0; i < data.length;) {\n\t    cmd = data[i++];\n\t    j = i;\n\t    nPoint = 0;\n\t\n\t    switch (cmd) {\n\t      case M:\n\t        nPoint = 1;\n\t        break;\n\t\n\t      case L:\n\t        nPoint = 1;\n\t        break;\n\t\n\t      case C:\n\t        nPoint = 3;\n\t        break;\n\t\n\t      case Q:\n\t        nPoint = 2;\n\t        break;\n\t\n\t      case A:\n\t        var x = m[4];\n\t        var y = m[5];\n\t        var sx = mathSqrt(m[0] * m[0] + m[1] * m[1]);\n\t        var sy = mathSqrt(m[2] * m[2] + m[3] * m[3]);\n\t        var angle = mathAtan2(-m[1] / sy, m[0] / sx); // cx\n\t\n\t        data[i] *= sx;\n\t        data[i++] += x; // cy\n\t\n\t        data[i] *= sy;\n\t        data[i++] += y; // Scale rx and ry\n\t        // FIXME Assume psi is 0 here\n\t\n\t        data[i++] *= sx;\n\t        data[i++] *= sy; // Start angle\n\t\n\t        data[i++] += angle; // end angle\n\t\n\t        data[i++] += angle; // FIXME psi\n\t\n\t        i += 2;\n\t        j = i;\n\t        break;\n\t\n\t      case R:\n\t        // x0, y0\n\t        p[0] = data[i++];\n\t        p[1] = data[i++];\n\t        v2ApplyTransform(p, p, m);\n\t        data[j++] = p[0];\n\t        data[j++] = p[1]; // x1, y1\n\t\n\t        p[0] += data[i++];\n\t        p[1] += data[i++];\n\t        v2ApplyTransform(p, p, m);\n\t        data[j++] = p[0];\n\t        data[j++] = p[1];\n\t    }\n\t\n\t    for (k = 0; k < nPoint; k++) {\n\t      var p = points[k];\n\t      p[0] = data[i++];\n\t      p[1] = data[i++];\n\t      v2ApplyTransform(p, p, m); // Write back\n\t\n\t      data[j++] = p[0];\n\t      data[j++] = p[1];\n\t    }\n\t  }\n\t}\n\t\n\tmodule.exports = _default;\n\n/***/ },\n/* 74 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar echarts = __webpack_require__(9);\n\t\n\t__webpack_require__(76);\n\t__webpack_require__(77);\n\t\n\t\n\techarts.registerVisual(\n\t    echarts.util.curry(\n\t        __webpack_require__(34), 'liquidFill'\n\t    )\n\t);\n\n\n/***/ },\n/* 75 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar echarts = __webpack_require__(9);\n\t\n\tmodule.exports = echarts.graphic.extendShape({\n\t    type: 'ec-liquid-fill',\n\t\n\t    shape: {\n\t        waveLength: 0,\n\t        radius: 0,\n\t        cx: 0,\n\t        cy: 0,\n\t        waterLevel: 0,\n\t        amplitude: 0,\n\t        phase: 0,\n\t        inverse: false\n\t    },\n\t\n\t    buildPath: function (ctx, shape) {\n\t        /**\n\t         * We define a sine wave having 4 waves, and make sure at least 8 curves\n\t         * is drawn. Otherwise, it may cause blank area for some waves when\n\t         * wave length is large enough.\n\t         */\n\t        var curves = Math.max(\n\t            Math.ceil(2 * shape.radius / shape.waveLength * 4) * 2,\n\t            8\n\t        );\n\t\n\t        // map phase to [-Math.PI * 2, 0]\n\t        while (shape.phase < -Math.PI * 2) {\n\t            shape.phase += Math.PI * 2;\n\t        }\n\t        while (shape.phase > 0) {\n\t            shape.phase -= Math.PI * 2;\n\t        }\n\t        var phase = shape.phase / Math.PI / 2 * shape.waveLength;\n\t\n\t        var left = shape.cx - shape.radius + phase - shape.radius * 2;\n\t\n\t        /**\n\t         * top-left corner as start point\n\t         *\n\t         * draws this point\n\t         *  |\n\t         * \\|/\n\t         *  ~~~~~~~~\n\t         *  |      |\n\t         *  +------+\n\t         */\n\t        ctx.moveTo(left, shape.waterLevel);\n\t\n\t        /**\n\t         * top wave\n\t         *\n\t         * ~~~~~~~~ <- draws this sine wave\n\t         * |      |\n\t         * +------+\n\t         */\n\t        var waveRight = 0;\n\t        for (var c = 0; c < curves; ++c) {\n\t            var stage = c % 4;\n\t            var pos = getWaterPositions(c * shape.waveLength / 4, stage,\n\t                shape.waveLength, shape.amplitude);\n\t            ctx.bezierCurveTo(pos[0][0] + left, -pos[0][1] + shape.waterLevel,\n\t                pos[1][0] + left, -pos[1][1] + shape.waterLevel,\n\t                pos[2][0] + left, -pos[2][1] + shape.waterLevel);\n\t\n\t            if (c === curves - 1) {\n\t                waveRight = pos[2][0];\n\t            }\n\t        }\n\t\n\t        if (shape.inverse) {\n\t            /**\n\t             * top-right corner\n\t             *                  2. draws this line\n\t             *                          |\n\t             *                       +------+\n\t             * 3. draws this line -> |      | <- 1. draws this line\n\t             *                       ~~~~~~~~\n\t             */\n\t            ctx.lineTo(waveRight + left, shape.cy - shape.radius);\n\t            ctx.lineTo(left, shape.cy - shape.radius);\n\t            ctx.lineTo(left, shape.waterLevel);\n\t        }\n\t        else {\n\t            /**\n\t             * top-right corner\n\t             *\n\t             *                       ~~~~~~~~\n\t             * 3. draws this line -> |      | <- 1. draws this line\n\t             *                       +------+\n\t             *                          ^\n\t             *                          |\n\t             *                  2. draws this line\n\t             */\n\t            ctx.lineTo(waveRight + left, shape.cy + shape.radius);\n\t            ctx.lineTo(left, shape.cy + shape.radius);\n\t            ctx.lineTo(left, shape.waterLevel);\n\t        }\n\t\n\t        ctx.closePath();\n\t    }\n\t});\n\t\n\t\n\t\n\t/**\n\t * Using Bezier curves to fit sine wave.\n\t * There is 4 control points for each curve of wave,\n\t * which is at 1/4 wave length of the sine wave.\n\t *\n\t * The control points for a wave from (a) to (d) are a-b-c-d:\n\t *          c *----* d\n\t *     b *\n\t *       |\n\t * ... a * ..................\n\t *\n\t * whose positions are a: (0, 0), b: (0.5, 0.5), c: (1, 1), d: (PI / 2, 1)\n\t *\n\t * @param {number} x          x position of the left-most point (a)\n\t * @param {number} stage      0-3, stating which part of the wave it is\n\t * @param {number} waveLength wave length of the sine wave\n\t * @param {number} amplitude  wave amplitude\n\t */\n\tfunction getWaterPositions(x, stage, waveLength, amplitude) {\n\t    if (stage === 0) {\n\t        return [\n\t            [x + 1 / 2 * waveLength / Math.PI / 2, amplitude / 2],\n\t            [x + 1 / 2 * waveLength / Math.PI,     amplitude],\n\t            [x + waveLength / 4,                   amplitude]\n\t        ];\n\t    }\n\t    else if (stage === 1) {\n\t        return [\n\t            [x + 1 / 2 * waveLength / Math.PI / 2 * (Math.PI - 2),\n\t            amplitude],\n\t            [x + 1 / 2 * waveLength / Math.PI / 2 * (Math.PI - 1),\n\t            amplitude / 2],\n\t            [x + waveLength / 4,                   0]\n\t        ]\n\t    }\n\t    else if (stage === 2) {\n\t        return [\n\t            [x + 1 / 2 * waveLength / Math.PI / 2, -amplitude / 2],\n\t            [x + 1 / 2 * waveLength / Math.PI,     -amplitude],\n\t            [x + waveLength / 4,                   -amplitude]\n\t        ]\n\t    }\n\t    else {\n\t        return [\n\t            [x + 1 / 2 * waveLength / Math.PI / 2 * (Math.PI - 2),\n\t            -amplitude],\n\t            [x + 1 / 2 * waveLength / Math.PI / 2 * (Math.PI - 1),\n\t            -amplitude / 2],\n\t            [x + waveLength / 4,                   0]\n\t        ]\n\t    }\n\t}\n\n\n/***/ },\n/* 76 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar completeDimensions = __webpack_require__(27);\n\tvar echarts = __webpack_require__(9);\n\t\n\techarts.extendSeriesModel({\n\t\n\t    type: 'series.liquidFill',\n\t\n\t    visualColorAccessPath: 'textStyle.normal.color',\n\t\n\t    optionUpdated: function () {\n\t        var option = this.option;\n\t        option.gridSize = Math.max(Math.floor(option.gridSize), 4);\n\t    },\n\t\n\t    getInitialData: function (option, ecModel) {\n\t        var dimensions = completeDimensions(['value'], option.data);\n\t        var list = new echarts.List(dimensions, this);\n\t        list.initData(option.data);\n\t        return list;\n\t    },\n\t\n\t    defaultOption: {\n\t        color: ['#294D99', '#156ACF', '#1598ED', '#45BDFF'],\n\t        center: ['50%', '50%'],\n\t        radius: '50%',\n\t        amplitude: '8%',\n\t        waveLength: '80%',\n\t        phase: 'auto',\n\t        period: 'auto',\n\t        direction: 'right',\n\t        shape: 'circle',\n\t\n\t        waveAnimation: true,\n\t        animationEasing: 'linear',\n\t        animationEasingUpdate: 'linear',\n\t        animationDuration: 2000,\n\t        animationDurationUpdate: 1000,\n\t\n\t        outline: {\n\t            show: true,\n\t            borderDistance: 8,\n\t            itemStyle: {\n\t                color: 'none',\n\t                borderColor: '#294D99',\n\t                borderWidth: 8,\n\t                shadowBlur: 20,\n\t                shadowColor: 'rgba(0, 0, 0, 0.25)'\n\t            }\n\t        },\n\t\n\t        backgroundStyle: {\n\t            color: '#E3F7FF'\n\t        },\n\t\n\t        itemStyle: {\n\t            opacity: 0.95,\n\t            shadowBlur: 50,\n\t            shadowColor: 'rgba(0, 0, 0, 0.4)'\n\t        },\n\t\n\t        label: {\n\t            show: true,\n\t            color: '#294D99',\n\t            insideColor: '#fff',\n\t            fontSize: 50,\n\t            fontWeight: 'bold',\n\t\n\t            align: 'center',\n\t            baseline: 'middle',\n\t            position: 'inside'\n\t        },\n\t\n\t        emphasis: {\n\t            itemStyle: {\n\t                opacity: 0.8\n\t            }\n\t        }\n\t    }\n\t});\n\n\n/***/ },\n/* 77 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar echarts = __webpack_require__(9);\n\tvar numberUtil = echarts.number;\n\tvar symbolUtil = __webpack_require__(33);\n\tvar parsePercent = numberUtil.parsePercent;\n\t\n\tvar LiquidLayout = __webpack_require__(75);\n\t\n\tfunction getShallow(model, path) {\n\t    return model && model.getShallow(path);\n\t}\n\t\n\techarts.extendChartView({\n\t\n\t    type: 'liquidFill',\n\t\n\t    render: function (seriesModel, ecModel, api) {\n\t        var group = this.group;\n\t        group.removeAll();\n\t\n\t        var data = seriesModel.getData();\n\t\n\t        var itemModel = data.getItemModel(0);\n\t\n\t        var center = itemModel.get('center');\n\t        var radius = itemModel.get('radius');\n\t\n\t        var width = api.getWidth();\n\t        var height = api.getHeight();\n\t        var size = Math.min(width, height);\n\t        // itemStyle\n\t        var outlineDistance = 0;\n\t        var outlineBorderWidth = 0;\n\t        var showOutline = seriesModel.get('outline.show');\n\t\n\t        if (showOutline) {\n\t            outlineDistance = seriesModel.get('outline.borderDistance');\n\t            outlineBorderWidth = parsePercent(\n\t                seriesModel.get('outline.itemStyle.borderWidth'), size\n\t            );\n\t        }\n\t\n\t        var cx = parsePercent(center[0], width);\n\t        var cy = parsePercent(center[1], height);\n\t\n\t        var outterRadius;\n\t        var innerRadius;\n\t        var paddingRadius;\n\t\n\t        var isFillContainer = false;\n\t\n\t        var symbol = seriesModel.get('shape');\n\t        if (symbol === 'container') {\n\t            // a shape that fully fills the container\n\t            isFillContainer = true;\n\t\n\t            outterRadius = [\n\t                width / 2,\n\t                height / 2\n\t            ];\n\t            innerRadius = [\n\t                outterRadius[0] - outlineBorderWidth / 2,\n\t                outterRadius[1] - outlineBorderWidth / 2\n\t            ];\n\t            paddingRadius = [\n\t                parsePercent(outlineDistance, width),\n\t                parsePercent(outlineDistance, height)\n\t            ];\n\t\n\t            radius = [\n\t                innerRadius[0] - paddingRadius[0],\n\t                innerRadius[1] - paddingRadius[1]\n\t            ];\n\t        }\n\t        else {\n\t            outterRadius = parsePercent(radius, size) / 2;\n\t            innerRadius = outterRadius - outlineBorderWidth / 2;\n\t            paddingRadius = parsePercent(outlineDistance, size);\n\t\n\t            radius = innerRadius - paddingRadius;\n\t        }\n\t\n\t        if (showOutline) {\n\t            var outline = getOutline();\n\t            outline.style.lineWidth = outlineBorderWidth;\n\t            group.add(getOutline());\n\t        }\n\t\n\t        var left = isFillContainer ? 0 : cx - radius;\n\t        var top = isFillContainer ? 0 : cy - radius;\n\t\n\t        var wavePath = null;\n\t\n\t        group.add(getBackground());\n\t\n\t        // each data item for a wave\n\t        var oldData = this._data;\n\t        var waves = [];\n\t        data.diff(oldData)\n\t            .add(function (idx) {\n\t                var wave = getWave(idx, false);\n\t\n\t                var waterLevel = wave.shape.waterLevel;\n\t                wave.shape.waterLevel = isFillContainer ? radius[1] : radius;\n\t                echarts.graphic.initProps(wave, {\n\t                    shape: {\n\t                        waterLevel: waterLevel\n\t                    }\n\t                }, seriesModel);\n\t\n\t                wave.z2 = 2;\n\t                setWaveAnimation(idx, wave, null);\n\t\n\t                group.add(wave);\n\t                data.setItemGraphicEl(idx, wave);\n\t                waves.push(wave);\n\t            })\n\t            .update(function (newIdx, oldIdx) {\n\t                var waveElement = oldData.getItemGraphicEl(oldIdx);\n\t\n\t                // new wave is used to calculate position, but not added\n\t                var newWave = getWave(newIdx, false, waveElement);\n\t\n\t                // Shallow copy shape and style to avoid comparing style.host\n\t                // when animating\n\t                var shape = Object.assign({}, newWave.shape);\n\t                var style = Object.assign({}, newWave.style);\n\t                style.host = null;\n\t\n\t                // update old wave with parameters of new wave\n\t                echarts.graphic.updateProps(waveElement, {\n\t                    shape: shape,\n\t                    style: style\n\t                }, seriesModel);\n\t                waveElement.position = newWave.position;\n\t                waveElement.setClipPath(newWave.clipPath);\n\t\n\t                setWaveAnimation(newIdx, waveElement, waveElement);\n\t                group.add(waveElement);\n\t                data.setItemGraphicEl(newIdx, waveElement);\n\t                waves.push(waveElement);\n\t            })\n\t            .remove(function (idx) {\n\t                var wave = oldData.getItemGraphicEl(idx);\n\t                group.remove(wave);\n\t            })\n\t            .execute();\n\t\n\t        if (itemModel.get('label.show')) {\n\t            group.add(getText(waves));\n\t        }\n\t\n\t        this._data = data;\n\t\n\t        /**\n\t         * Get path for outline, background and clipping\n\t         *\n\t         * @param {number} r outter radius of shape\n\t         * @param {boolean|undefined} isForClipping if the shape is used\n\t         *                                          for clipping\n\t         */\n\t        function getPath(r, isForClipping) {\n\t            if (symbol) {\n\t                // customed symbol path\n\t                if (symbol.indexOf('path://') === 0) {\n\t                    var path = echarts.graphic.makePath(symbol.slice(7), {});\n\t                    var bouding = path.getBoundingRect();\n\t                    var w = bouding.width;\n\t                    var h = bouding.height;\n\t                    if (w > h) {\n\t                        h = r * 2 / w * h;\n\t                        w = r * 2;\n\t                    }\n\t                    else {\n\t                        w = r * 2 / h * w;\n\t                        h = r * 2;\n\t                    }\n\t\n\t                    var left = isForClipping ? 0 : cx - w / 2;\n\t                    var top = isForClipping ? 0 : cy - h / 2;\n\t                    path = echarts.graphic.makePath(\n\t                        symbol.slice(7),\n\t                        {},\n\t                        new echarts.graphic.BoundingRect(left, top, w, h)\n\t                    );\n\t                    if (isForClipping) {\n\t                        path.position = [-w / 2, -h / 2];\n\t                    }\n\t                    return path;\n\t                }\n\t                else if (isFillContainer) {\n\t                    // fully fill the container\n\t                    var x = isForClipping ? -r[0] : cx - r[0];\n\t                    var y = isForClipping ? -r[1] : cy - r[1];\n\t                    return symbolUtil.createSymbol(\n\t                        'rect', x, y, r[0] * 2, r[1] * 2\n\t                    );\n\t                }\n\t                else {\n\t                    var x = isForClipping ? -r : cx - r;\n\t                    var y = isForClipping ? -r : cy - r;\n\t                    if (symbol === 'pin') {\n\t                        y += r;\n\t                    }\n\t                    else if (symbol === 'arrow') {\n\t                        y -= r;\n\t                    }\n\t                    return symbolUtil.createSymbol(symbol, x, y, r * 2, r * 2);\n\t                }\n\t            }\n\t\n\t            return new echarts.graphic.Circle({\n\t                shape: {\n\t                    cx: isForClipping ? 0 : cx,\n\t                    cy: isForClipping ? 0 : cy,\n\t                    r: r\n\t                }\n\t            });\n\t        }\n\t        /**\n\t         * Create outline\n\t         */\n\t        function getOutline() {\n\t            var outlinePath = getPath(outterRadius);\n\t            outlinePath.style.fill = null;\n\t\n\t            outlinePath.setStyle(seriesModel.getModel('outline.itemStyle')\n\t                .getItemStyle());\n\t\n\t            return outlinePath;\n\t        }\n\t\n\t        /**\n\t         * Create background\n\t         */\n\t        function getBackground() {\n\t            // Seperate stroke and fill, so we can use stroke to cover the alias of clipping.\n\t            var strokePath = getPath(radius);\n\t            strokePath.setStyle(seriesModel.getModel('backgroundStyle')\n\t                .getItemStyle());\n\t            strokePath.style.fill = null;\n\t\n\t            // Stroke is front of wave\n\t            strokePath.z2 = 5;\n\t\n\t            var fillPath = getPath(radius);\n\t            fillPath.setStyle(seriesModel.getModel('backgroundStyle')\n\t                .getItemStyle());\n\t            fillPath.style.stroke = null;\n\t\n\t            var group = new echarts.graphic.Group();\n\t            group.add(strokePath);\n\t            group.add(fillPath);\n\t\n\t            return group;\n\t        }\n\t\n\t        /**\n\t         * wave shape\n\t         */\n\t        function getWave(idx, isInverse, oldWave) {\n\t            var radiusX = isFillContainer ? radius[0] : radius;\n\t            var radiusY = isFillContainer ? radius[1] : radius;\n\t\n\t            var itemModel = data.getItemModel(idx);\n\t            var itemStyleModel = itemModel.getModel('itemStyle');\n\t            var phase = itemModel.get('phase');\n\t            var amplitude = parsePercent(itemModel.get('amplitude'),\n\t                radiusY * 2);\n\t            var waveLength = parsePercent(itemModel.get('waveLength'),\n\t                radiusX * 2);\n\t\n\t            var value = data.get('value', idx);\n\t            var waterLevel = radiusY - value * radiusY * 2;\n\t            phase = oldWave ? oldWave.shape.phase\n\t                : (phase === 'auto' ? idx * Math.PI / 4 : phase);\n\t            var normalStyle = itemStyleModel.getItemStyle();\n\t            if (!normalStyle.fill) {\n\t                var seriesColor = seriesModel.get('color');\n\t                var id = idx % seriesColor.length;\n\t                normalStyle.fill = seriesColor[id];\n\t            }\n\t\n\t            var x = radiusX * 2;\n\t            var wave = new LiquidLayout({\n\t                shape: {\n\t                    waveLength: waveLength,\n\t                    radius: radiusX,\n\t                    cx: x,\n\t                    cy: 0,\n\t                    waterLevel: waterLevel,\n\t                    amplitude: amplitude,\n\t                    phase: phase,\n\t                    inverse: isInverse\n\t                },\n\t                style: normalStyle,\n\t                position: [cx, cy]\n\t            });\n\t            wave.shape._waterLevel = waterLevel;\n\t\n\t            var hoverStyle = itemModel.getModel('emphasis.itemStyle')\n\t                .getItemStyle();\n\t            hoverStyle.lineWidth = 0;\n\t            echarts.graphic.setHoverStyle(wave, hoverStyle);\n\t\n\t            // clip out the part outside the circle\n\t            var clip = getPath(radius, true);\n\t            // set fill for clipPath, otherwise it will not trigger hover event\n\t            clip.setStyle({\n\t                fill: 'white'\n\t            });\n\t            wave.setClipPath(clip);\n\t\n\t            return wave;\n\t        }\n\t\n\t        function setWaveAnimation(idx, wave, oldWave) {\n\t            var itemModel = data.getItemModel(idx);\n\t\n\t            var maxSpeed = itemModel.get('period');\n\t            var direction = itemModel.get('direction');\n\t\n\t            var value = data.get('value', idx);\n\t\n\t            var phase = itemModel.get('phase');\n\t            phase = oldWave ? oldWave.shape.phase\n\t                : (phase === 'auto' ? idx * Math.PI / 4 : phase);\n\t\n\t            var defaultSpeed = function (maxSpeed) {\n\t                var cnt = data.count();\n\t                return cnt === 0 ? maxSpeed : maxSpeed *\n\t                    (0.2 + (cnt - idx) / cnt * 0.8);\n\t            };\n\t            var speed = 0;\n\t            if (maxSpeed === 'auto') {\n\t                speed = defaultSpeed(5000);\n\t            }\n\t            else {\n\t                speed = typeof maxSpeed === 'function'\n\t                    ? maxSpeed(value, idx) : maxSpeed;\n\t            }\n\t\n\t            // phase for moving left/right\n\t            var phaseOffset = 0;\n\t            if (direction === 'right' || direction == null) {\n\t                phaseOffset = Math.PI;\n\t            }\n\t            else if (direction === 'left') {\n\t                phaseOffset = -Math.PI;\n\t            }\n\t            else if (direction === 'none') {\n\t                phaseOffset = 0;\n\t            }\n\t            else {\n\t                console.error('Illegal direction value for liquid fill.');\n\t            }\n\t\n\t            // wave animation of moving left/right\n\t            if (direction !== 'none' && itemModel.get('waveAnimation')) {\n\t                wave\n\t                    .animate('shape', true)\n\t                    .when(0, {\n\t                        phase: phase\n\t                    })\n\t                    .when(speed / 2, {\n\t                        phase: phaseOffset + phase\n\t                    })\n\t                    .when(speed, {\n\t                        phase: phaseOffset * 2 + phase\n\t                    })\n\t                    .during(function () {\n\t                        if (wavePath) {\n\t                            wavePath.dirty(true);\n\t                        }\n\t                    })\n\t                    .start();\n\t            }\n\t        }\n\t\n\t        /**\n\t         * text on wave\n\t         */\n\t        function getText(waves) {\n\t            var labelModel = itemModel.getModel('label');\n\t\n\t            function formatLabel() {\n\t                var formatted = seriesModel.getFormattedLabel(0, 'normal');\n\t                var defaultVal = (data.get('value', 0) * 100);\n\t                var defaultLabel = data.getName(0) || seriesModel.name;\n\t                if (!isNaN(defaultVal)) {\n\t                    defaultLabel = defaultVal.toFixed(0) + '%';\n\t                }\n\t                return formatted == null ? defaultLabel : formatted;\n\t            }\n\t\n\t            var textOption = {\n\t                z2: 10,\n\t                shape: {\n\t                    x: left,\n\t                    y: top,\n\t                    width: (isFillContainer ? radius[0] : radius) * 2,\n\t                    height: (isFillContainer ? radius[1] : radius) * 2\n\t                },\n\t                style: {\n\t                    fill: 'transparent',\n\t                    text: formatLabel(),\n\t                    textAlign: labelModel.get('align'),\n\t                    textVerticalAlign: labelModel.get('baseline')\n\t                },\n\t                silent: true\n\t            };\n\t\n\t            var outsideTextRect = new echarts.graphic.Rect(textOption);\n\t            var color = labelModel.get('color');\n\t            echarts.graphic.setText(outsideTextRect.style, labelModel, color);\n\t\n\t            var insideTextRect = new echarts.graphic.Rect(textOption);\n\t            var insColor = labelModel.get('insideColor');\n\t            echarts.graphic.setText(insideTextRect.style, labelModel, insColor);\n\t            insideTextRect.style.textFill = insColor;\n\t\n\t            var group = new echarts.graphic.Group();\n\t            group.add(outsideTextRect);\n\t            group.add(insideTextRect);\n\t\n\t            // clip out waves for insideText\n\t            var boundingCircle = getPath(radius, true);\n\t\n\t            wavePath = new echarts.graphic.CompoundPath({\n\t                shape: {\n\t                    paths: waves\n\t                },\n\t                position: [cx, cy]\n\t            });\n\t\n\t            wavePath.setClipPath(boundingCircle);\n\t            insideTextRect.setClipPath(wavePath);\n\t\n\t            return group;\n\t        }\n\t    },\n\t\n\t    dispose: function () {\n\t        // dispose nothing here\n\t    }\n\t});\n\n\n/***/ }\n/******/ ])\n});\n;\n\n\n// WEBPACK FOOTER //\n// echarts-liquidfill.min.js"," \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\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\texports: {},\n \t\t\tid: moduleId,\n \t\t\tloaded: false\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.loaded = 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// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(0);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap c84def07b18966073981","module.exports = require('./src/liquidFill');\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./index.js\n// module id = 0\n// module chunks = 0","/**\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);\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} // Add prefix to avoid conflict with Object.prototype.\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.hasOwnProperty(key) ? this[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[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) {\n      this.hasOwnProperty(key) && cb(this[key], key);\n    }\n  },\n  // Do not use this method if performance sensitive.\n  removeKey: function (key) {\n    delete this[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//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/core/util.js\n// module id = 1\n// module chunks = 0","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  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    hasFill && path.fill(ctx);\n\n    if (lineDash && ctxLineDash) {\n      ctx.setLineDash(lineDash);\n      ctx.lineDashOffset = lineDashOffset;\n    }\n\n    hasStroke && path.stroke(ctx);\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 = 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//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/graphic/Path.js\n// module id = 2\n// module chunks = 0","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;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/core/vector.js\n// module id = 3\n// module chunks = 0","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;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/core/BoundingRect.js\n// module id = 4\n// module chunks = 0","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;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/core/curve.js\n// module id = 5\n// module chunks = 0","// (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\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/echarts/lib/config.js\n// module id = 6\n// module chunks = 0","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 + cx;\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          var psi = data[i++];\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//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/core/PathProxy.js\n// module id = 7\n// module chunks = 0","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  // inplace is used with incremental\n  inplace: false,\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 = 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//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/graphic/Displayable.js\n// module id = 8\n// module chunks = 0","module.exports = __WEBPACK_EXTERNAL_MODULE_9__;\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"echarts\"\n// module id = 9\n// module chunks = 0","/**\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//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/core/matrix.js\n// module id = 10\n// module chunks = 0","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 && (image = new Image());\n      image.onload = 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.__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//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/graphic/helper/image.js\n// module id = 11\n// module chunks = 0","var _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 * [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//////////////////\n// WEBPACK FOOTER\n// ./~/echarts/lib/data/Source.js\n// module id = 12\n// module chunks = 0","// 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//////////////////\n// WEBPACK FOOTER\n// ./~/echarts/lib/data/helper/sourceType.js\n// module id = 13\n// module chunks = 0","var zrUtil = require(\"zrender/lib/core/util\");\n\nvar each = zrUtil.each;\nvar isObject = zrUtil.isObject;\nvar isArray = zrUtil.isArray;\n/**\n * name may be displayed on screen, so use '-'.\n * But we should make sure it is not duplicated\n * with user specified name, so use '\\0';\n */\n\nvar DEFAULT_COMPONENT_NAME = '\\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  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 : DEFAULT_COMPONENT_NAME;\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/**\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\nexports.DEFAULT_COMPONENT_NAME = DEFAULT_COMPONENT_NAME;\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.isIdInner = isIdInner;\nexports.compressBatches = compressBatches;\nexports.queryDataIndex = queryDataIndex;\nexports.makeInner = makeInner;\nexports.parseFinder = parseFinder;\nexports.setAttribute = setAttribute;\nexports.getAttribute = getAttribute;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/echarts/lib/util/model.js\n// module id = 14\n// module chunks = 0","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;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/Element.js\n// module id = 15\n// module chunks = 0","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;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/config.js\n// module id = 16\n// module chunks = 0","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, rich, truncate) {\n  return rich ? getRichTextRect(text, font, textAlign, textVerticalAlign, textPadding, rich, truncate) : getPlainTextRect(text, font, textAlign, textVerticalAlign, textPadding, truncate);\n}\n\nfunction getPlainTextRect(text, font, textAlign, textVerticalAlign, textPadding, truncate) {\n  var contentBlock = parsePlainText(text, font, textPadding, 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, rich, truncate) {\n  var contentBlock = parseRichText(text, {\n    rich: rich,\n    truncate: truncate,\n    font: font,\n    textAlign: textAlign,\n    textPadding: textPadding\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);\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, truncate) {\n  text != null && (text += '');\n  var lineHeight = 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//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/contain/text.js\n// module id = 17\n// module chunks = 0","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;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/contain/util.js\n// module id = 18\n// module chunks = 0","// 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//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/core/LRU.js\n// module id = 19\n// module chunks = 0","/**\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//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/graphic/Gradient.js\n// module id = 20\n// module chunks = 0","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;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/graphic/helper/fixShadow.js\n// module id = 21\n// module chunks = 0","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\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/graphic/helper/poly.js\n// module id = 22\n// module chunks = 0","function 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.quadraticCurveTo(x + width, y, x + width, y + r2);\n  ctx.lineTo(x + width, y + height - r3);\n  r3 !== 0 && ctx.quadraticCurveTo(x + width, y + height, x + width - r3, y + height);\n  ctx.lineTo(x + r4, y + height);\n  r4 !== 0 && ctx.quadraticCurveTo(x, y + height, x, y + height - r4);\n  ctx.lineTo(x, y + r1);\n  r1 !== 0 && ctx.quadraticCurveTo(x, y, x + r1, y);\n}\n\nexports.buildPath = buildPath;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/graphic/helper/roundRect.js\n// module id = 23\n// module chunks = 0","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\n// TODO: Have not support 'start', 'end' yet.\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};\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 */\n\n\nfunction renderText(hostEl, ctx, text, style, rect) {\n  style.rich ? renderRichText(hostEl, ctx, text, style, rect) : renderPlainText(hostEl, ctx, text, style, rect);\n}\n\nfunction renderPlainText(hostEl, ctx, text, style, rect) {\n  var font = setCtx(ctx, 'font', style.font || textContain.DEFAULT_FONT);\n  var textPadding = style.textPadding;\n  var contentBlock = hostEl.__textCotentBlock;\n\n  if (!contentBlock || hostEl.__dirty) {\n    contentBlock = hostEl.__textCotentBlock = textContain.parsePlainText(text, font, textPadding, 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;\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  var needDrawBg = needDrawBackground(style);\n\n  if (needDrawBg || textPadding) {\n    // Consider performance, do not call getTextWidth util necessary.\n    var textWidth = textContain.getWidth(text, font);\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  }\n\n  setCtx(ctx, 'textAlign', textAlign || 'left'); // 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'); // Always set shadowBlur and shadowOffset to avoid leak from displayable.\n\n  setCtx(ctx, 'shadowBlur', style.textShadowBlur || 0);\n  setCtx(ctx, 'shadowColor', style.textShadowColor || 'transparent');\n  setCtx(ctx, 'shadowOffsetX', style.textShadowOffsetX || 0);\n  setCtx(ctx, 'shadowOffsetY', style.textShadowOffsetY || 0); // `textBaseline` is set as 'middle'.\n\n  textY += lineHeight / 2;\n  var textStrokeWidth = style.textStrokeWidth;\n  var textStroke = getStroke(style.textStroke, textStrokeWidth);\n  var textFill = getFill(style.textFill);\n\n  if (textStroke) {\n    setCtx(ctx, 'lineWidth', textStrokeWidth);\n    setCtx(ctx, 'strokeStyle', textStroke);\n  }\n\n  if (textFill) {\n    setCtx(ctx, 'fillStyle', textFill);\n  }\n\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\nfunction renderRichText(hostEl, ctx, text, style, rect) {\n  var contentBlock = hostEl.__textCotentBlock;\n\n  if (!contentBlock || hostEl.__dirty) {\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] || {}; // '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 || textContain.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}\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    ctx.fill();\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    ctx.stroke();\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//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/graphic/helper/text.js\n// module id = 24\n// module chunks = 0","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\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  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 = [];\n/**\n * 分解`transform`矩阵到`position`, `rotation`, `scale`\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 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 * Get global scale\n * @return {Array.<number>}\n */\n\n\ntransformableProto.getGlobalScale = function () {\n  var m = this.transform;\n\n  if (!m) {\n    return [1, 1];\n  }\n\n  var sx = Math.sqrt(m[0] * m[0] + m[1] * m[1]);\n  var sy = Math.sqrt(m[2] * m[2] + m[3] * m[3]);\n\n  if (m[0] < 0) {\n    sx = -sx;\n  }\n\n  if (m[3] < 0) {\n    sy = -sy;\n  }\n\n  return [sx, sy];\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//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/mixin/Transformable.js\n// module id = 25\n// module chunks = 0","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      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\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//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/tool/color.js\n// module id = 26\n// module chunks = 0","var _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 * @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...]}, ...] can be specified to give names.\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.extraPrefix] Prefix of name when filling the left dimensions.\n * @param {string} [opt.extraFromZero] If specified, extra dim names will be:\n *                      extraPrefix + 0, extraPrefix + extraBaseIndex + 1 ...\n *                      If not specified, extra dim names will be:\n *                      extraPrefix, extraPrefix + 0, extraPrefix + 1 ...\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 *      isSysCoord: boolean True if the coord is from sys dimension.\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 or undefined.\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();\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 = normalizeToArray(encodeDef.get(coordDim)); // 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        resultItem.name = resultItem.displayName = sysDimItemDimsDef[coordDimIndex];\n      }\n\n      resultItem.isSysCoord = true; // FIXME refactor, currently only used in case: {otherDims: {tooltip: false}}\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 extra = opt.extraPrefix || '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    coordDim == null && (resultItem.coordDim = genName(extra, coordDimNameMap, opt.extraFromZero), resultItem.coordDimIndex = 0, resultItem.isExtraCoord = true);\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\n\nfunction getDimCount(source, sysDims, dimsDef, dimCount) {\n  if (dimCount == null) {\n    dimCount = Math.max(source.dimensionsDetectCount || 1, sysDims.length, dimsDef.length);\n    each(sysDims, function (sysDimItem) {\n      var sysDimItemDimsDef = sysDimItem.dimsDef;\n      sysDimItemDimsDef && (dimCount = Math.max(dimCount, sysDimItemDimsDef.length));\n    });\n  }\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//////////////////\n// WEBPACK FOOTER\n// ./~/echarts/lib/data/helper/completeDimensions.js\n// module id = 27\n// module chunks = 0","var _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__;\nvar OTHER_DIMENSIONS = createHashMap(['tooltip', 'label', 'itemName', 'itemId', 'seriesName']);\n\nfunction summarizeDimensions(data) {\n  var summary = {};\n  var encode = summary.encode = {};\n  var coordDimMap = summary.coordDimMap = createHashMap();\n  var defaultedLabel = [];\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.isSysCoord && mayLabelDimType(dimItem.type)) {\n        // Use the last coord dim (and label friendly) as default label,\n        // because both show x, y on label is not look good, and usually\n        // y axis is more focusd conventionally.\n        defaultedLabel[0] = dimName;\n      }\n\n      coordDimMap.set(coordDim, 1);\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  coordDimMap.each(function (v, coordDim) {\n    dataDimsOnCoord = dataDimsOnCoord.concat(encode[coordDim]);\n  });\n  summary.dataDimsOnCoord = dataDimsOnCoord;\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 defaultedTooltip = defaultedLabel.slice();\n  var encodeTooltip = encode.tooltip;\n\n  if (encodeTooltip && encodeTooltip.length) {\n    defaultedTooltip = encodeTooltip.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//////////////////\n// WEBPACK FOOTER\n// ./~/echarts/lib/data/helper/dimensionHelper.js\n// module id = 28\n// module chunks = 0","var _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;\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    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//////////////////\n// WEBPACK FOOTER\n// ./~/echarts/lib/data/helper/sourceHelper.js\n// module id = 29\n// module chunks = 0","var _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 * 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//////////////////\n// WEBPACK FOOTER\n// ./~/echarts/lib/model/referHelper.js\n// module id = 30\n// module chunks = 0","var _config = require(\"../config\");\n\nvar __DEV__ = _config.__DEV__;\n\nvar zrUtil = require(\"zrender/lib/core/util\");\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//////////////////\n// WEBPACK FOOTER\n// ./~/echarts/lib/util/clazz.js\n// module id = 31\n// module chunks = 0","var 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;\nvar round = Math.round;\nvar mathMax = Math.max;\nvar mathMin = Math.min;\nvar EMPTY_OBJ = {};\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  var boundingRect = path.getBoundingRect();\n\n  if (rect) {\n    if (layout === 'center') {\n      rect = centerGraphic(rect, boundingRect);\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}\n\nfunction liftColor(color) {\n  return typeof color === 'string' ? colorTool.lift(color, -0.1) : color;\n}\n/**\n * @private\n */\n\n\nfunction cacheElementStl(el) {\n  if (el.__hoverStlDirty) {\n    var stroke = el.style.stroke;\n    var fill = el.style.fill; // Create hoverStyle on mouseover\n\n    var hoverStyle = el.__hoverStl;\n    hoverStyle.fill = hoverStyle.fill || (hasFillOrStroke(fill) ? liftColor(fill) : null);\n    hoverStyle.stroke = hoverStyle.stroke || (hasFillOrStroke(stroke) ? liftColor(stroke) : null);\n    var normalStyle = {};\n\n    for (var name in hoverStyle) {\n      // See comment in `doSingleEnterHover`.\n      if (hoverStyle[name] != null) {\n        normalStyle[name] = el.style[name];\n      }\n    }\n\n    el.__normalStl = normalStyle;\n    el.__hoverStlDirty = false;\n  }\n}\n/**\n * @private\n */\n\n\nfunction doSingleEnterHover(el) {\n  if (el.__isHover) {\n    return;\n  }\n\n  cacheElementStl(el);\n\n  if (el.useHoverLayer) {\n    el.__zr && el.__zr.addHover(el, el.__hoverStl);\n  } else {\n    var style = el.style;\n    var insideRollbackOpt = style.insideRollbackOpt; // Consider case: only `position: 'top'` is set on emphasis, then text\n    // color should be returned to `autoColor`, rather than remain '#fff'.\n    // So we should rollback then apply again after style merging.\n\n    insideRollbackOpt && rollbackInsideStyle(style); // 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    style.extendFrom(el.__hoverStl); // Do not save `insideRollback`.\n\n    if (insideRollbackOpt) {\n      applyInsideStyle(style, style.insideOriginalTextPosition, insideRollbackOpt); // textFill may be rollbacked to null.\n\n      if (style.textFill == null) {\n        style.textFill = insideRollbackOpt.autoColor;\n      }\n    }\n\n    el.dirty(false);\n    el.z2 += 1;\n  }\n\n  el.__isHover = true;\n}\n/**\n * @inner\n */\n\n\nfunction doSingleLeaveHover(el) {\n  if (!el.__isHover) {\n    return;\n  }\n\n  var normalStl = el.__normalStl;\n\n  if (el.useHoverLayer) {\n    el.__zr && el.__zr.removeHover(el);\n  } else {\n    // Consider null/undefined value, should use\n    // `setStyle` but not `extendFrom(stl, true)`.\n    normalStl && el.setStyle(normalStl);\n    el.z2 -= 1;\n  }\n\n  el.__isHover = false;\n}\n/**\n * @inner\n */\n\n\nfunction doEnterHover(el) {\n  el.type === 'group' ? el.traverse(function (child) {\n    if (child.type !== 'group') {\n      doSingleEnterHover(child);\n    }\n  }) : doSingleEnterHover(el);\n}\n\nfunction doLeaveHover(el) {\n  el.type === 'group' ? el.traverse(function (child) {\n    if (child.type !== 'group') {\n      doSingleLeaveHover(child);\n    }\n  }) : doSingleLeaveHover(el);\n}\n/**\n * @inner\n */\n\n\nfunction setElementHoverStl(el, hoverStl) {\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  el.__hoverStl = el.hoverStyle || hoverStl || {};\n  el.__hoverStlDirty = true;\n\n  if (el.__isHover) {\n    cacheElementStl(el);\n  }\n}\n/**\n * @inner\n */\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.__isEmphasis && doEnterHover(this);\n}\n/**\n * @inner\n */\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.__isEmphasis && doLeaveHover(this);\n}\n/**\n * @inner\n */\n\n\nfunction enterEmphasis() {\n  this.__isEmphasis = true;\n  doEnterHover(this);\n}\n/**\n * @inner\n */\n\n\nfunction leaveEmphasis() {\n  this.__isEmphasis = false;\n  doLeaveHover(this);\n}\n/**\n * Set hover style of element.\n * This method can be called repeatly without side-effects.\n * @param {module:zrender/Element} el\n * @param {Object} [hoverStyle]\n * @param {Object} [opt]\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 *        conviniently 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 setHoverStyle(el, hoverStyle, opt) {\n  el.__hoverSilentOnTouch = opt && opt.hoverSilentOnTouch;\n  el.type === 'group' ? el.traverse(function (child) {\n    if (child.type !== 'group') {\n      setElementHoverStl(child, hoverStyle);\n    }\n  }) : setElementHoverStl(el, hoverStyle); // Duplicated function will be auto-ignored, see Eventful.js.\n\n  el.on('mouseover', onElementMouseOver).on('mouseout', onElementMouseOut); // Emphasis, normal can be triggered manually\n\n  el.on('emphasis', enterEmphasis).on('normal', leaveEmphasis);\n}\n/**\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 * @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);\n  textStyle.host && textStyle.host.dirty && textStyle.host.dirty(false);\n  return textStyle;\n}\n/**\n * Set text option in the style.\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);\n  textStyle.host && textStyle.host.dirty && textStyle.host.dirty(false);\n}\n/**\n * {\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);\n\n  if (!isEmphasis) {\n    if (isBlock) {\n      // Always set `insideRollback`, for clearing previous.\n      var originalTextPosition = textStyle.textPosition;\n      textStyle.insideRollback = applyInsideStyle(textStyle, originalTextPosition, opt); // Save original textPosition, because style.textPosition will be repalced by\n      // real location (like [10, 30]) in zrender.\n\n      textStyle.insideOriginalTextPosition = originalTextPosition;\n      textStyle.insideRollbackOpt = opt;\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\nfunction applyInsideStyle(textStyle, textPosition, opt) {\n  var useInsideStyle = opt.useInsideStyle;\n  var insideRollback;\n\n  if (textStyle.textFill == null && 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 = opt.autoColor;\n      textStyle.textStrokeWidth == null && (textStyle.textStrokeWidth = 2);\n    }\n  }\n\n  return insideRollback;\n}\n\nfunction rollbackInsideStyle(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  }\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  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);\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.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.setHoverStyle = setHoverStyle;\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//////////////////\n// WEBPACK FOOTER\n// ./~/echarts/lib/util/graphic.js\n// module id = 32\n// module chunks = 0","var zrUtil = require(\"zrender/lib/core/util\");\n\nvar graphic = require(\"./graphic\");\n\nvar BoundingRect = require(\"zrender/lib/core/BoundingRect\");\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//////////////////\n// WEBPACK FOOTER\n// ./~/echarts/lib/util/symbol.js\n// module id = 33\n// module chunks = 0","var _util = require(\"zrender/lib/core/util\");\n\nvar createHashMap = _util.createHashMap;\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), 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// WEBPACK FOOTER\n// ./~/echarts/lib/visual/dataColor.js\n// module id = 34\n// module chunks = 0","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;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/animation/Animator.js\n// module id = 35\n// module chunks = 0","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\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/animation/Clip.js\n// module id = 36\n// module chunks = 0","/**\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//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/animation/easing.js\n// module id = 37\n// module chunks = 0","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;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/contain/arc.js\n// module id = 38\n// module chunks = 0","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;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/contain/cubic.js\n// module id = 39\n// module chunks = 0","/**\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//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/contain/line.js\n// module id = 40\n// module chunks = 0","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_, 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        var psi = data[i++];\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//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/contain/path.js\n// module id = 41\n// module chunks = 0","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;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/contain/quadratic.js\n// module id = 42\n// module chunks = 0","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;\n  return x_ > x ? dir : 0;\n}\n\nmodule.exports = windingLine;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/contain/windingLine.js\n// module id = 43\n// module chunks = 0","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;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/container/Group.js\n// module id = 44\n// module chunks = 0","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;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/core/bbox.js\n// module id = 45\n// module chunks = 0","/**\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 !== 'undefined') {\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  };\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  };\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  };\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  };\n}\n\nmodule.exports = _default;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/core/env.js\n// module id = 46\n// module chunks = 0","/**\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//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/core/guid.js\n// module id = 47\n// module chunks = 0","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;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/core/log.js\n// module id = 48\n// module chunks = 0","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;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/graphic/CompoundPath.js\n// module id = 49\n// module chunks = 0","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;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/graphic/Image.js\n// module id = 50\n// module chunks = 0","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 too 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._temporaryDisplayables[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//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/graphic/IncrementalDisplayable.js\n// module id = 51\n// module chunks = 0","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;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/graphic/LinearGradient.js\n// module id = 52\n// module chunks = 0","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;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/graphic/Pattern.js\n// module id = 53\n// module chunks = 0","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;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/graphic/RadialGradient.js\n// module id = 54\n// module chunks = 0","var fixShadow = require(\"./helper/fixShadow\");\n\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, host) {\n  this.extendFrom(opts, false);\n  this.host = host;\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  }\n\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 {module:zrender/graphic/Displayable}\n   */\n  host: null,\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 {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;\n    var firstDraw = !prevStyle;\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 (firstDraw || 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 (firstDraw || style.fill !== prevStyle.fill) {\n      ctx.fillStyle = style.fill;\n    }\n\n    if (firstDraw || style.stroke !== prevStyle.stroke) {\n      ctx.strokeStyle = style.stroke;\n    }\n\n    if (firstDraw || style.opacity !== prevStyle.opacity) {\n      ctx.globalAlpha = style.opacity == null ? 1 : style.opacity;\n    }\n\n    if (firstDraw || 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//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/graphic/Style.js\n// module id = 55\n// module chunks = 0","var Displayable = require(\"./Displayable\");\n\nvar zrUtil = require(\"../core/util\");\n\nvar textContain = require(\"../contain/text\");\n\nvar textHelper = require(\"./helper/text\");\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 += ''); // Always bind style\n\n    style.bind(ctx, this, prevEl);\n\n    if (!textHelper.needDrawText(text, style)) {\n      return;\n    }\n\n    this.setTransform(ctx);\n    textHelper.renderText(this, ctx, text, style);\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.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//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/graphic/Text.js\n// module id = 56\n// module chunks = 0","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;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/graphic/helper/fixClipWithShadow.js\n// module id = 57\n// module chunks = 0","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, 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//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/graphic/helper/smoothBezier.js\n// module id = 58\n// module chunks = 0","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;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/graphic/helper/smoothSpline.js\n// module id = 59\n// module chunks = 0","var textHelper = require(\"../helper/text\");\n\nvar BoundingRect = require(\"../../core/BoundingRect\");\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\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);\n    ctx.restore();\n  }\n};\nvar _default = RectText;\nmodule.exports = _default;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/graphic/mixin/RectText.js\n// module id = 60\n// module chunks = 0","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;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/graphic/shape/Arc.js\n// module id = 61\n// module chunks = 0","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;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/graphic/shape/BezierCurve.js\n// module id = 62\n// module chunks = 0","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;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/graphic/shape/Circle.js\n// module id = 63\n// module chunks = 0","var Path = require(\"../Path\");\n\n/**\n * 直线\n * @module zrender/graphic/shape/Line\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 = shape.x1;\n    var y1 = shape.y1;\n    var x2 = shape.x2;\n    var y2 = shape.y2;\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//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/graphic/shape/Line.js\n// module id = 64\n// module chunks = 0","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;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/graphic/shape/Polygon.js\n// module id = 65\n// module chunks = 0","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;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/graphic/shape/Polyline.js\n// module id = 66\n// module chunks = 0","var Path = require(\"../Path\");\n\nvar roundRectHelper = require(\"../helper/roundRect\");\n\n/**\n * 矩形\n * @module zrender/graphic/shape/Rect\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 = shape.x;\n    var y = shape.y;\n    var width = shape.width;\n    var height = shape.height;\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//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/graphic/shape/Rect.js\n// module id = 67\n// module chunks = 0","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;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/graphic/shape/Ring.js\n// module id = 68\n// module chunks = 0","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;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/graphic/shape/Sector.js\n// module id = 69\n// module chunks = 0","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(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    this.stopAnimation();\n\n    this._animateToShallow('', this, target, time, delay); // Animators may be removed immediately after start\n    // if there is nothing to animate\n\n\n    var animators = this.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  /**\n   * @private\n   * @param {string} path=''\n   * @param {Object} source=this\n   * @param {Object} target\n   * @param {number} [time=500]\n   * @param {number} [delay=0]\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  _animateToShallow: function (path, source, target, time, delay) {\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          this._animateToShallow(path ? path + '.' + name : name, source[name], target[name], time, delay);\n        } else {\n          objShallow[name] = target[name];\n          propertyCount++;\n        }\n      } else if (target[name] != null) {\n        // Attr directly if not has property\n        // FIXME, if some property not needed for element ?\n        if (!path) {\n          this.attr(name, target[name]);\n        } else {\n          // Shape or style\n          var props = {};\n          props[path] = {};\n          props[path][name] = target[name];\n          this.attr(props);\n        }\n      }\n    }\n\n    if (propertyCount > 0) {\n      this.animate(path, false).when(time == null ? 500 : time, objShallow).delay(delay || 0);\n    }\n\n    return this;\n  }\n};\nvar _default = Animatable;\nmodule.exports = _default;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/mixin/Animatable.js\n// module id = 70\n// module chunks = 0","/**\n * 事件扩展\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 * 事件分发器\n * @alias module:zrender/mixin/Eventful\n * @constructor\n */\n\nvar Eventful = function () {\n  this._$handlers = {};\n};\n\nEventful.prototype = {\n  constructor: Eventful,\n\n  /**\n   * 单次触发绑定，trigger后销毁\n   *\n   * @param {string} event 事件名\n   * @param {Function} handler 响应函数\n   * @param {Object} context\n   */\n  one: function (event, handler, context) {\n    var _h = this._$handlers;\n\n    if (!handler || !event) {\n      return this;\n    }\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 this;\n      }\n    }\n\n    _h[event].push({\n      h: handler,\n      one: true,\n      ctx: context || this\n    });\n\n    return this;\n  },\n\n  /**\n   * 绑定事件\n   * @param {string} event 事件名\n   * @param {Function} handler 事件处理函数\n   * @param {Object} [context]\n   */\n  on: function (event, handler, context) {\n    var _h = this._$handlers;\n\n    if (!handler || !event) {\n      return this;\n    }\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 this;\n      }\n    }\n\n    _h[event].push({\n      h: handler,\n      one: false,\n      ctx: context || this\n    });\n\n    return this;\n  },\n\n  /**\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   * 解绑事件\n   * @param {string} event 事件名\n   * @param {Function} [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   * 事件分发\n   *\n   * @param {string} type 事件类型\n   */\n  trigger: function (type) {\n    if (this._$handlers[type]) {\n      var args = arguments;\n      var argLen = args.length;\n\n      if (argLen > 3) {\n        args = arrySlice.call(args, 1);\n      }\n\n      var _h = this._$handlers[type];\n      var len = _h.length;\n\n      for (var i = 0; i < len;) {\n        // Optimize advise from backbone\n        switch (argLen) {\n          case 1:\n            _h[i]['h'].call(_h[i]['ctx']);\n\n            break;\n\n          case 2:\n            _h[i]['h'].call(_h[i]['ctx'], args[1]);\n\n            break;\n\n          case 3:\n            _h[i]['h'].call(_h[i]['ctx'], args[1], args[2]);\n\n            break;\n\n          default:\n            // have more than 2 given arguments\n            _h[i]['h'].apply(_h[i]['ctx'], args);\n\n            break;\n        }\n\n        if (_h[i]['one']) {\n          _h.splice(i, 1);\n\n          len--;\n        } else {\n          i++;\n        }\n      }\n    }\n\n    return this;\n  },\n\n  /**\n   * 带有context的事件分发, 最后一个参数是事件回调的context\n   * @param {string} type 事件类型\n   */\n  triggerWithContext: function (type) {\n    if (this._$handlers[type]) {\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 _h = this._$handlers[type];\n      var len = _h.length;\n\n      for (var i = 0; i < len;) {\n        // Optimize advise from backbone\n        switch (argLen) {\n          case 1:\n            _h[i]['h'].call(ctx);\n\n            break;\n\n          case 2:\n            _h[i]['h'].call(ctx, args[1]);\n\n            break;\n\n          case 3:\n            _h[i]['h'].call(ctx, args[1], args[2]);\n\n            break;\n\n          default:\n            // have more than 2 given arguments\n            _h[i]['h'].apply(ctx, args);\n\n            break;\n        }\n\n        if (_h[i]['one']) {\n          _h.splice(i, 1);\n\n          len--;\n        } else {\n          i++;\n        }\n      }\n    }\n\n    return this;\n  }\n}; // 对象可以通过 onxxxx 绑定事件\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\nvar _default = Eventful;\nmodule.exports = _default;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/mixin/Eventful.js\n// module id = 71\n// module chunks = 0","var Path = require(\"../graphic/Path\");\n\nvar PathProxy = require(\"../core/PathProxy\");\n\nvar transformPath = require(\"./transformPath\");\n\n// command chars\nvar cc = ['m', 'M', 'l', 'L', 'v', 'V', 'h', 'H', 'z', 'Z', 'c', 'C', 'q', 'Q', 't', 'T', 's', 'S', 'a', 'A'];\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\nfunction createPathProxyFromString(data) {\n  if (!data) {\n    return [];\n  } // command string\n\n\n  var cs = data.replace(/-/g, ' -').replace(/  /g, ' ').replace(/ /g, ',').replace(/,,/g, ',');\n  var n; // create pipes so that we can split the data\n\n  for (n = 0; n < cc.length; n++) {\n    cs = cs.replace(new RegExp(cc[n], 'g'), '|' + cc[n]);\n  } // create array\n\n\n  var arr = cs.split('|'); // init context point\n\n  var cpx = 0;\n  var cpy = 0;\n  var path = new PathProxy();\n  var CMD = PathProxy.CMD;\n  var prevCmd;\n\n  for (n = 1; n < arr.length; n++) {\n    var str = arr[n];\n    var c = str.charAt(0);\n    var off = 0;\n    var p = str.slice(1).replace(/e,-/g, 'e-').split(',');\n    var cmd;\n\n    if (p.length > 0 && p[0] === '') {\n      p.shift();\n    }\n\n    for (var i = 0; i < p.length; i++) {\n      p[i] = parseFloat(p[i]);\n    }\n\n    while (off < p.length && !isNaN(p[off])) {\n      if (isNaN(p[0])) {\n        break;\n      }\n\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 (c) {\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          c = '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          c = '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 (c === 'z' || c === 'Z') {\n      cmd = CMD.Z;\n      path.addData(cmd);\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//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/tool/path.js\n// module id = 72\n// module chunks = 0","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;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zrender/lib/tool/transformPath.js\n// module id = 73\n// module chunks = 0","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\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/liquidFill.js\n// module id = 74\n// module chunks = 0","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        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        /**\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.radius);\n            ctx.lineTo(left, shape.cy - shape.radius);\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.radius);\n            ctx.lineTo(left, shape.cy + shape.radius);\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//////////////////\n// WEBPACK FOOTER\n// ./src/liquidFillLayout.js\n// module id = 75\n// module chunks = 0","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\n//////////////////\n// WEBPACK FOOTER\n// ./src/liquidFillSeries.js\n// module id = 76\n// module chunks = 0","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                innerRadius[0] - paddingRadius[0],\n                innerRadius[1] - paddingRadius[1]\n            ];\n        }\n        else {\n            outterRadius = parsePercent(radius, size) / 2;\n            innerRadius = outterRadius - outlineBorderWidth / 2;\n            paddingRadius = parsePercent(outlineDistance, size);\n\n            radius = innerRadius - paddingRadius;\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 ? radius[1] : 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                // Shallow copy shape and style to avoid comparing style.host\n                // when animating\n                var shape = Object.assign({}, newWave.shape);\n                var style = Object.assign({}, newWave.style);\n                style.host = null;\n\n                // update old wave with parameters of new wave\n                echarts.graphic.updateProps(waveElement, {\n                    shape: shape,\n                    style: style\n                }, seriesModel);\n                waveElement.position = newWave.position;\n                waveElement.setClipPath(newWave.clipPath);\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 ? radius[1] : 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                    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//////////////////\n// WEBPACK FOOTER\n// ./src/liquidFillView.js\n// module id = 77\n// module chunks = 0"],"sourceRoot":""}